@rio-cloud/rio-uikit 1.2.2 → 1.3.0

package/DateRangePicker.d.ts

@@ -1,12 +1,12 @@
-import type { Component, JSX, PropsWithChildren, ReactNode } from 'react';
+import type { JSX, PropsWithChildren, ReactNode } from 'react';
 import type { Moment } from 'moment/moment';
-export interface DateRangePickerCustomPresets {
+export type DateRangePickerCustomPresets = {
     startValue: Moment;
     endValue: Moment;
     text: string | JSX.Element;
     onSelect?: Function;
-}
-export interface DateRangePickerProps {
+};
+export type DateRangePickerProps = {
     startValue?: Moment;
     endValue?: Moment;
     defaultStartValue?: Moment;
@@ -34,11 +34,10 @@ export interface DateRangePickerProps {
     dropup?: boolean;
     pullRight?: boolean;
     autoDropDirection?: boolean;
-}
+};
 /**
  * Wrapper component for React-Datetime.
  *
  * @deprecated This will be removed from the UIKIT at some time.
  */
-declare const DateRangePicker: Component<PropsWithChildren<DateRangePickerProps>, {}, any>;
-export { DateRangePicker };
+export declare const DateRangePicker: (props: PropsWithChildren<DateRangePickerProps>) => import("react/jsx-runtime").JSX.Element;

package/DateRangePicker.js

@@ -1,8 +1,12 @@
-import { default as _DateRangePicker } from './components/datepicker/DateRangePicker';
+import { __rest } from "tslib";
+import { jsx as _jsx } from "react/jsx-runtime";
+import DeprecatedDateRangePicker from './components/datepicker/DateRangePicker';
 /**
  * Wrapper component for React-Datetime.
  *
  * @deprecated This will be removed from the UIKIT at some time.
  */
-const DateRangePicker = _DateRangePicker;
-export { DateRangePicker };
+export const DateRangePicker = (props) => {
+    const { children } = props, remainingProps = __rest(props, ["children"]);
+    return _jsx(DeprecatedDateRangePicker, Object.assign({}, remainingProps, { children: children }));
+};

package/README.md

@@ -19,9 +19,9 @@ When releasing a new version:
 
 Create a new development beta version:
 
-1. Update the `package.json`. Example `0.16.4-beta.1`
-2. Update the `src/version.json`. Example `0.16.4-beta.1`
-3. run `npm i` or update `package-lock.json`. Example `0.16.4-beta.1`
+1. Update the `package.json`. Example `1.2.4-beta.1`
+2. Update the `src/version.json`. Example `1.2.4-beta.1`
+3. run `npm i` or update `package-lock.json`. Example `1.2.4-beta.1`
 
 ## Development
 

package/components/actionBarItem/ActionBarItem.js

@@ -97,7 +97,7 @@ const ActionBarItemBase = (props) => {
         return (_jsxs("div", Object.assign({}, remainingProps, { className: classes, ref: clickOutsideRef }, { children: [React.cloneElement(itemIcon, { onClick: onToggle }), _jsx("div", Object.assign({ onClick: () => setIsShown(false) }, { children: _jsx(Dialog, { show: isShown, onClose: () => setIsShown(false), body: itemPopover, bodyClassName: mobileDialogBodyClassName, title: title }) })), childrenWithoutPopoverAndIcon] })));
     }
     const overlay = (_jsx(ActionBarOverlay, Object.assign({ id: id, title: title, width: popoverWidth, preRender: useOffscreen, show: isShown }, { children: itemPopover }), 'child'));
-    return (_jsxs("div", Object.assign({}, remainingProps, { className: classes, ref: clickOutsideRef }, { children: [_jsx(OverlayTrigger, Object.assign({ onToggle: onToggle, show: isShown || useOffscreen, placement: OverlayTrigger.BOTTOM_END, overlay: overlay, trigger: 'click', rootClose: false, popperConfig: {
+    return (_jsxs("div", Object.assign({}, remainingProps, { className: classes, ref: clickOutsideRef }, { children: [_jsx(OverlayTrigger, Object.assign({ onToggle: onToggle, show: isShown || useOffscreen, placement: OverlayTrigger.BOTTOM_END, overlay: overlay, rootClose: false, trigger: 'click', popperConfig: {
                     modifiers: [
                         {
                             name: 'offset',
@@ -105,6 +105,10 @@ const ActionBarItemBase = (props) => {
                                 offset: [0, 5],
                             },
                         },
+                        {
+                            name: 'arrow',
+                            options: {},
+                        },
                     ],
                 } }, { children: itemIcon })), childrenWithoutPopoverAndIcon] })));
 };

package/components/actionBarItem/ActionBarItemIcon.d.ts

@@ -1,9 +1,7 @@
-import { type HTMLAttributes, type PropsWithChildren } from 'react';
-type ActionBarItemIconProps = HTMLAttributes<HTMLDivElement> & {
-    className?: string;
-};
-declare const ActionBarItemIcon: {
-    (props: PropsWithChildren<ActionBarItemIconProps>): import("react/jsx-runtime").JSX.Element;
-    displayName: string;
-};
+import React from 'react';
+declare const ActionBarItemIcon: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+    className?: string | undefined;
+} & {
+    children?: React.ReactNode;
+} & React.RefAttributes<HTMLDivElement>>;
 export default ActionBarItemIcon;

package/components/actionBarItem/ActionBarItemIcon.js

@@ -1,13 +1,13 @@
 import { __rest } from "tslib";
 import { jsx as _jsx } from "react/jsx-runtime";
 // @ts-ignore-next-line importsNotUsedAsValues
-import 'react';
+import { forwardRef } from 'react';
 import classNames from 'classnames';
-const ActionBarItemIcon = (props) => {
+const ActionBarItemIcon = forwardRef((props, ref) => {
     const { className, children } = props, remainingProps = __rest(props, ["className", "children"]);
     const classes = classNames('ActionBarItemIcon', className);
-    return (_jsx("div", Object.assign({}, remainingProps, { className: classes }, { children: children })));
-};
+    return (_jsx("div", Object.assign({}, remainingProps, { className: classes, ref: ref }, { children: children })));
+});
 // The displayName is used in ActionBarItem for checking the component "isActionBarItemIcon"
 ActionBarItemIcon.displayName = 'ActionBarItemIcon';
 export default ActionBarItemIcon;

package/components/actionBarItem/ActionBarOverlay.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
-import { type Placement } from '../../values/Placement';
+import { PLACEMENT_MAP } from '../popover/Popover';
+import type { ObjectValues } from '../../utils/ObjectValues';
 export type ActionBarOverlayWidth = 100 | 150 | 200 | 250 | 300 | 350 | 400 | 450 | 500;
 export type ActionBarOverlayProps = {
     id: string;
@@ -9,7 +10,7 @@ export type ActionBarOverlayProps = {
     width?: ActionBarOverlayWidth;
     onClick?: () => void;
     style?: object;
-    placement?: Placement;
+    placement?: ObjectValues<typeof PLACEMENT_MAP>;
     className?: string;
 };
 declare const ActionBarOverlay: React.ForwardRefExoticComponent<ActionBarOverlayProps & {

package/components/actionBarItem/ActionBarOverlay.js

@@ -1,18 +1,18 @@
 import { __rest } from "tslib";
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// @ts-ignore-next-line importsNotUsedAsValues
 import { forwardRef } from 'react';
 import classNames from 'classnames';
-import Popover from 'react-bootstrap/Popover';
 import noop from 'lodash/fp/noop';
-import { PLACEMENT } from '../../values/Placement';
-const DEFAULT_PLACEMENT = PLACEMENT.BOTTOM;
+import Popover, { PLACEMENT_MAP } from '../popover/Popover';
+const DEFAULT_PLACEMENT = PLACEMENT_MAP.BOTTOM;
 const DEFAULT_WIDTH = 250;
 const ActionBarOverlay = forwardRef((props, ref) => {
-    const { children, show, preRender, id, title, onClick = noop, width = DEFAULT_WIDTH, style = {}, className, placement = DEFAULT_PLACEMENT } = props, rest = __rest(props, ["children", "show", "preRender", "id", "title", "onClick", "width", "style", "className", "placement"]);
+    const { children, show, preRender, id, title, onClick = noop, width = DEFAULT_WIDTH, style = {}, className, placement = DEFAULT_PLACEMENT } = props, remainingProps = __rest(props, ["children", "show", "preRender", "id", "title", "onClick", "width", "style", "className", "placement"]);
     const adjustedStyles = Object.assign(Object.assign({}, style), { width });
     const adjustedClassName = preRender && !show ? classNames(className, 'position-offscreen') : className;
-    const popoverTitleClasses = classNames('ActionBarItemPopover popover-title text-color-dark', className);
-    const popoverContentClasses = classNames('ActionBarItemPopover popover-content', className);
-    return (_jsxs(Popover, Object.assign({ ref: ref, id: id, onClick: onClick, placement: placement }, rest, { style: adjustedStyles, className: adjustedClassName }, { children: [title && _jsx(Popover.Title, Object.assign({ className: popoverTitleClasses }, { children: title })), _jsx(Popover.Content, Object.assign({ className: popoverContentClasses }, { children: children }))] })));
+    const popoverTitleClasses = classNames('ActionBarItemPopover text-color-dark', className);
+    const popoverContentClasses = classNames('ActionBarItemPopover', className);
+    return (_jsxs(Popover, Object.assign({ ref: ref, id: id, onClick: onClick, placement: placement }, remainingProps, { style: adjustedStyles, className: adjustedClassName }, { children: [title && _jsx(Popover.Title, Object.assign({ className: popoverTitleClasses }, { children: title })), _jsx(Popover.Content, Object.assign({ className: popoverContentClasses }, { children: children }))] })));
 });
 export default ActionBarOverlay;

package/components/applicationLayout/ApplicationLayout.js

@@ -7,6 +7,7 @@ import ApplicationLayoutHeader from './ApplicationLayoutHeader';
 import ApplicationLayoutSidebar from './ApplicationLayoutSidebar';
 import ApplicationLayoutBody from './ApplicationLayoutBody';
 import { initDocumentBootstrapping } from '../../utils/init/initDocumentBootstrapping';
+import '../../utils/init/initConfig';
 // initializes document bootstrapping - keep the import to avoid being tree-shaken
 // noinspection JSIgnoredPromiseFromCall
 initDocumentBootstrapping();

package/components/applicationLayout/ApplicationLayoutHeader.js

@@ -1,14 +1,10 @@
 import { __rest } from "tslib";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { forwardRef } from 'react';
-import PropTypes from 'prop-types';
 import classNames from 'classnames';
 const ApplicationLayoutHeader = forwardRef((props, ref) => {
     const { className, children } = props, remainingProps = __rest(props, ["className", "children"]);
     const classes = classNames('ApplicationLayoutHeader', className);
     return (_jsx("div", Object.assign({ ref: ref }, remainingProps, { className: classes, id: 'ApplicationLayoutHeader' }, { children: children })));
 });
-ApplicationLayoutHeader.propTypes = {
-    className: PropTypes.string,
-};
 export default ApplicationLayoutHeader;

package/components/assetTree/TreeOptions.js

@@ -12,7 +12,7 @@ const TreeOptions = (props) => {
     }
     const dropdownClasses = classNames('display-flex flex-column gap-10', 'width-250', 'padding-15', className);
     const customDropdown = _jsx("div", Object.assign({ className: dropdownClasses }, { children: treeOptions }));
-    const dropdown = (_jsx(ButtonDropdown, { title: _jsx("span", { className: 'rioglyph rioglyph-option-vertical', "aria-hidden": 'true' }), bsStyle: 'default', bsSize: 'sm', customDropdown: customDropdown, toggleClassName: 'hover-bg-white border-none text-color-gray hover-text-color-dark', className: 'TreeHeaderOptions', pullRight: true, iconOnly: true }));
+    const dropdown = (_jsx(ButtonDropdown, { title: _jsx("span", { className: 'rioglyph rioglyph-option-vertical', "aria-hidden": 'true' }), bsStyle: 'default', bsSize: 'sm', customDropdown: customDropdown, toggleClassName: 'hover-bg-white border-none text-color-gray hover-text-color-dark', className: 'TreeHeaderOptions height-20', pullRight: true, iconOnly: true }));
     if (treeOptionsTooltip) {
         return (_jsx(SimpleTooltip, Object.assign({ content: treeOptionsTooltip, placement: 'bottom', delay: { show: 1000, hide: 0 }, popperConfig: {
                 modifiers: [

package/components/assetTree/treeUtils.js

@@ -27,7 +27,7 @@ const orderByName = orderBy([
         var _a;
         return isNameObject(item)
             ? item.name.lastName.toLowerCase()
-            : (_a = item.name.toLowerCase()) !== null && _a !== void 0 ? _a : '';
+            : ((_a = item.name.toLowerCase()) !== null && _a !== void 0 ? _a : '');
     },
 ], ['asc']);
 // TODO: extend to use provided external search function instead?

package/components/calendarStripe/CalendarStripe.d.ts

@@ -62,6 +62,14 @@ export type CalendarStripeProps = {
      * Additional classes set to the calendar element.
      */
     className?: string;
+    /**
+     * Additional classes set to the days wrapper element.
+     */
+    daysWrapperClassName?: string;
+    /**
+     * Additional classes set to the days wrapper element.
+     */
+    dayWrapperClassName?: string;
 };
 declare const CalendarStripe: React.ForwardRefExoticComponent<CalendarStripeProps & React.RefAttributes<HTMLDivElement>>;
 export default CalendarStripe;

package/components/calendarStripe/CalendarStripe.js

@@ -6,6 +6,7 @@ import noop from 'lodash/noop';
 import useAfterMount from '../../hooks/useAfterMount';
 import useElementSize from '../../hooks/useElementSize';
 import usePrevious from '../../hooks/usePrevious';
+import { hasAlignItemsClass, hasAlignSelfClass, hasBgClass, hasBorderClass, hasCursorClass, hasDisplayClass, hasFlexClass, hasHoverScaleClass, hasHoverTextColorClass, hasOverflowClass, hasPaddingClass, hasRoundedClass, hasSpaceClass, hasTextColorClass, hasTextSizeClass, hasUserSelectClass, } from '../../utils/hasUtilityClass';
 const DEFAULT_MIN_WITH = 200;
 const DEFAULT_MIN_DAYS = 1;
 const DEFAULT_MAX_DAYS = 7;
@@ -28,7 +29,7 @@ const getFirstColumnItem = (node) => {
     return getFirstColumnItem(node.children[0]);
 };
 const CalendarStripe = forwardRef((props, ref) => {
-    const { minDayWith = DEFAULT_MIN_WITH, minDays = DEFAULT_MIN_DAYS, maxDays = DEFAULT_MAX_DAYS, render, renderDay, skipWeekends = false, startDate = new Date(), onNextClick = noop, onPreviousClick = noop, buttonClassName = '', className = '', } = props;
+    const { minDayWith = DEFAULT_MIN_WITH, minDays = DEFAULT_MIN_DAYS, maxDays = DEFAULT_MAX_DAYS, render, renderDay, skipWeekends = false, startDate = new Date(), onNextClick = noop, onPreviousClick = noop, buttonClassName = '', className = '', daysWrapperClassName = '', dayWrapperClassName = '', } = props;
     if (render) {
         console.warn('CalendarStripe has set the "render" prop deprecated. This will be removed in the upcoming releases,' +
             ' Please use the "renderDay" prop instead.');
@@ -114,8 +115,10 @@ const CalendarStripe = forwardRef((props, ref) => {
             addDays = false;
         }
     }
-    const wrapperClassName = classNames('CalenderStripe', 'display-flex', 'align-items-center', 'overflow-hidden', 'bg-white', 'border', 'rounded', className);
-    const baseButtonClassName = classNames('align-items-center', 'align-self-stretch', 'display-flex', 'hover-scale-105', 'hover-text-color-darkest', 'padding-10', 'cursor-pointer', 'text-color-darker', 'text-size-12', buttonClassName);
-    return (_jsxs("div", Object.assign({ ref: ref, className: wrapperClassName }, { children: [_jsx("div", Object.assign({ className: baseButtonClassName, onClick: handlePrev }, { children: _jsx("span", { className: 'rioglyph rioglyph-chevron-left' }) })), _jsx("div", Object.assign({ className: 'flex-1-1 overflow-hidden', ref: columnWrapperRef }, { children: _jsx(AnimatePresence, Object.assign({ exitBeforeEnter: true, custom: animationDirection }, { children: _jsx(motion.div, Object.assign({ variants: variants, initial: enableInitialAnimation ? 'pageEnter' : false, animate: 'pageCenter', custom: animationDirection, transition: { duration: ANIMATION_DURATION } }, { children: _jsx("div", Object.assign({ className: 'ColumnWrapper display-flex space-x--1 user-select-none' }, { children: dates.map(date => (_jsxs("div", Object.assign({ className: `${ITEM_NAME} flex-1-1` }, { children: [renderDay ? renderDay(date) : null, render && React.cloneElement(_jsx(_Fragment, { children: render }), { date })] }), `${getDateString(date)}`))) })) }), getDateString(firstDate)) })) })), _jsx("div", Object.assign({ className: baseButtonClassName, onClick: handleNext }, { children: _jsx("span", { className: 'rioglyph rioglyph-chevron-right' }) }))] })));
+    const wrapperClassNames = classNames('CalenderStripe', !hasDisplayClass(className) && 'display-flex', !hasAlignItemsClass(className) && 'align-items-center', !hasOverflowClass(className) && 'overflow-hidden', !hasBgClass(className) && 'bg-white', !hasBorderClass(className) && 'border', !hasRoundedClass(className) && 'rounded', className);
+    const baseButtonClassNames = classNames(!hasAlignItemsClass(buttonClassName) && 'align-items-center', !hasDisplayClass(buttonClassName) && 'display-flex', !hasHoverScaleClass(buttonClassName) && 'hover-scale-105', !hasHoverTextColorClass(buttonClassName) && 'hover-text-color-darkest', !hasPaddingClass(buttonClassName) && 'padding-10', !hasCursorClass(buttonClassName) && 'cursor-pointer', !hasTextColorClass(buttonClassName) && 'text-color-darker', !hasTextSizeClass(buttonClassName) && 'text-size-12', !hasAlignSelfClass(buttonClassName) && 'align-self-stretch', buttonClassName);
+    const daysWrapperClassNames = classNames(!hasDisplayClass(daysWrapperClassName) && 'display-flex', !hasSpaceClass(daysWrapperClassName) && 'space-x--1', !hasUserSelectClass(daysWrapperClassName) && 'user-select-none', daysWrapperClassName);
+    const dayWrapperClassNames = classNames(ITEM_NAME, !hasFlexClass(dayWrapperClassName) && 'flex-1-1-0', !hasSpaceClass(dayWrapperClassName) && 'space-x--1', !hasUserSelectClass(dayWrapperClassName) && 'user-select-none', dayWrapperClassName);
+    return (_jsxs("div", Object.assign({ ref: ref, className: wrapperClassNames }, { children: [_jsx("div", Object.assign({ className: baseButtonClassNames, onClick: handlePrev }, { children: _jsx("span", { className: 'rioglyph rioglyph-chevron-left' }) })), _jsx("div", Object.assign({ className: 'flex-1-1 overflow-hidden', ref: columnWrapperRef }, { children: _jsx(AnimatePresence, Object.assign({ exitBeforeEnter: true, custom: animationDirection }, { children: _jsx(motion.div, Object.assign({ variants: variants, initial: enableInitialAnimation ? 'pageEnter' : false, animate: 'pageCenter', custom: animationDirection, transition: { duration: ANIMATION_DURATION } }, { children: _jsx("div", Object.assign({ className: daysWrapperClassNames }, { children: dates.map(date => (_jsxs("div", Object.assign({ className: dayWrapperClassNames }, { children: [renderDay ? renderDay(date) : null, render && React.cloneElement(_jsx(_Fragment, { children: render }), { date })] }), `${getDateString(date)}`))) })) }), getDateString(firstDate)) })) })), _jsx("div", Object.assign({ className: baseButtonClassNames, onClick: handleNext }, { children: _jsx("span", { className: 'rioglyph rioglyph-chevron-right' }) }))] })));
 });
 export default CalendarStripe;

package/components/dataTabs/DataTab.js

@@ -5,7 +5,8 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import 'react';
 import { motion } from 'framer-motion';
 const DataTab = (props) => {
-    const { active = false, tabKey, disableTransition = false, className = '', children } = props, remainingProps = __rest(props, ["active", "tabKey", "disableTransition", "className", "children"]);
+    const { active = false, title, // exclude from remainingProps to avoid being set to the div element
+    tabKey, disableTransition = false, className = '', children } = props, remainingProps = __rest(props, ["active", "title", "tabKey", "disableTransition", "className", "children"]);
     if (disableTransition) {
         return _jsx("div", { children: active && children });
     }

package/components/dialog/SimpleDialog.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
-import { type BaseDialogProps } from './Dialog';
-export type SimpleDialogProps = BaseDialogProps & {
+import { type DialogProps } from './Dialog';
+export type SimpleDialogProps = Omit<DialogProps, 'body'> & {
     /**
      * The content of the dialog body itself.
      */

package/components/dialog/SplitDialog.d.ts

@@ -25,6 +25,12 @@ export type SplitDialogProps = BaseDialogProps & {
      * Additional classes for the modal-footer element.
      */
     footerClassName?: string;
+    /**
+     * A callback function to be executed before closing the dialog. If the function returns
+     * `false` the dialog will not be closed
+     * @returns
+     */
+    onCloseValidation?: () => boolean;
 };
 declare const SplitDialog: (props: SplitDialogProps) => import("react/jsx-runtime").JSX.Element;
 export default SplitDialog;

package/components/expander/ExpanderList.js

@@ -3,6 +3,7 @@ import { useState } from 'react';
 import isEqual from 'lodash/fp/isEqual';
 import classNames from 'classnames';
 import Collapse from '../collapse/Collapse';
+import { hasBorderClass, hasRoundedClass } from '../../utils/hasUtilityClass';
 const getRandomString = () => (Math.random() + 1).toString(36).toUpperCase().substring(2);
 // Generate a unique id (if not present) instead of using the index for the key as it will create
 // side effects when removing items from the list and re-render the ExpanderList.
@@ -38,7 +39,7 @@ const ExpanderList = (props) => {
         });
         setListItems(updatedListItems);
     };
-    const listClassNames = classNames('expander-list list-group', rounded && 'rounded', bordered && 'border', className);
+    const listClassNames = classNames('expander-list list-group', rounded && !hasRoundedClass(className) && 'rounded', bordered && !hasBorderClass(className) && 'border', className);
     return (_jsx("ul", Object.assign({ className: listClassNames }, { children: listItems.map(item => {
             const isOpen = item.open;
             const itemClassNames = classNames('list-group-item', item.className && item.className, item.body && 'expandable', isOpen && 'open');

package/components/listMenu/ListMenu.js

@@ -66,7 +66,7 @@ const ListMenu = (props) => {
             setIsExpanderOpen(false);
         }
     };
-    const formClassNames = classNames('form-group', 'margin-bottom-5', 'padding-left-15', 'padding-right-15', 'padding-bottom-15', 'position-sticky', 'top-0');
+    const formClassNames = classNames('form-group', 'margin-top-5', 'margin-bottom-5', 'padding-left-15', 'padding-right-15', 'padding-bottom-15', 'position-sticky', 'top-0');
     const listMenu = (_jsxs("div", Object.assign({}, remainingProps, { className: `ListMenu ${className}`, ref: listRef }, { children: [enableFilter && (_jsx("div", Object.assign({ className: formClassNames }, { children: _jsxs("div", Object.assign({ className: 'input-group width-100pct' }, { children: [_jsx("span", Object.assign({ className: 'input-group-addon' }, { children: _jsx("span", { className: 'rioglyph rioglyph-search', "aria-hidden": 'true' }) })), _jsx(ClearableInput, { value: filterValue, inputRef: inputRef, placeholder: filterPlaceholder, onChange: handleFilterChange, onClear: handleClear }), trailingInputAddon && trailingInputAddon] })) }))), !hasMenuItems(filteredMenuItems) && (_jsx("div", Object.assign({ className: 'padding-top-25 text-center text-color-gray' }, { children: notFoundMessage }))), filteredMenuItems.map(menuGroup => (_jsx(ListMenuGroup, { className: groupClassName, menuGroup: menuGroup }, crypto.randomUUID())))] })));
     if (responsive && isMobileMode) {
         return (_jsx(ExpanderPanel, Object.assign({ title: mobileHeader, bsStyle: 'default', open: isExpanderOpen, onToggle: () => setIsExpanderOpen(!isExpanderOpen), unmountOnExit: false, className: 'shadow-default' }, { children: _jsx("div", Object.assign({ onClick: handleExpanderBodyClick }, { children: listMenu })) })));

package/components/onboarding/OnboardingTip.d.ts

@@ -1,14 +1,14 @@
 import React, { type PropsWithChildren, type ReactNode } from 'react';
-import type { OverlayProps } from 'react-bootstrap';
+import type { Options } from '@popperjs/core';
 import { type TooltipWidth } from '../tooltip/Tooltip';
 import { type TextAlignment } from '../../values/TextAlignment';
 import { type Placement } from '../../values/Placement';
-type PopperConfig = OverlayProps['popperConfig'];
 export type OnboardingButton = {
     text: string | React.ReactNode;
     onClick?: (event: React.MouseEvent<HTMLButtonElement>) => void;
     iconName?: string;
 };
+type PopperConfig = Partial<Options>;
 export type OnboardingTipProps = {
     /**
      * The ID of the DOM element.

package/components/onboarding/OnboardingTip.js

@@ -21,6 +21,8 @@ const OnboardingTip = (props) => {
                 // Popper.js default is false but we enable it by default
                 options: { altAxis: preventOverflow },
             },
+            // Use an arrow modifier, the arrow ref will be injected in OverlayTrigger with the right props
+            { name: 'arrow', options: {} },
         ],
     };
     const trigger = (_jsx(OverlayTrigger, Object.assign({ placement: placement, trigger: 'click', overlay: overlay, onToggle: onHide, show: show, rootClose: false, popperConfig: actualPopperConfig }, { children: children })));

package/components/overlay/OverlayTrigger.d.ts

@@ -1,6 +1,95 @@
-import { type PropsWithChildren } from 'react';
-import { type OverlayTriggerProps as BSOverlayTriggerProps } from 'react-bootstrap/OverlayTrigger';
-export type OverlayTriggerProps = Omit<BSOverlayTriggerProps, 'children'>;
+import React, { type PropsWithChildren } from 'react';
+import type { Options } from '@popperjs/core';
+import { type Placement } from '../../values/Placement';
+import { type TriggerType } from '../../values/Trigger';
+type PopperConfig = Partial<Options>;
+export type OverlayTriggerProps = {
+    /**
+     * The visibility of the Overlay. `show` is a _controlled_ prop so should be paired
+     * with `onToggle` to avoid breaking user interactions.
+     *
+     * Manually toggling `show` does **not** wait for `delay` to change the visibility.
+     *
+     * @controllable onToggle
+     * @default: false
+     */
+    show?: boolean;
+    /**
+     * The initial visibility state of the Overlay.
+     *
+     * @default false
+     */
+    defaultShow?: boolean;
+    /**
+     * Defines the usage of React Portal.
+     *
+     * @default true
+     */
+    enablePortal?: boolean;
+    /**
+     * Specify which action or actions trigger Overlay visibility
+     *
+     * The `click` trigger ignores the configured `delay`.
+     *
+     * @default 'hover'
+     */
+    trigger?: TriggerType;
+    /**
+     * A millisecond delay amount to show and hide the Overlay once triggered
+     */
+    delay?: number | {
+        show?: number;
+        hide?: number;
+    };
+    /**
+     * An element or text to overlay next to the target.
+     */
+    overlay: React.ReactElement;
+    /**
+     * The placement of the Overlay in relation to it's `target`.
+     *
+     * @default 'top'
+     */
+    placement?: Placement;
+    /**
+     * A Popper.js config object passed to the underlying popper instance.
+     * If no custom config is provided, a default config will be used. This default config
+     * includes an arrow element. In case you want to use a custom config and an arrow, include the arrow
+     * modifier so the correct arrow element can be injected for the arrow modifier.
+     *
+     * @example
+     * popperConfig={{
+     *     modifiers: [
+     *          {
+     *              name: 'offset',
+     *              options: {
+     *                  offset: [0, 5],
+     *              },
+     *          },
+     *          {
+     *              name: 'arrow',
+     *              options: {},
+     *          },
+     *      ],
+     *  }}
+     */
+    popperConfig?: PopperConfig;
+    /**
+     * Specify whether the overlay should trigger onHide when the user clicks outside the overlay.
+     *
+     * @default true
+     */
+    rootClose?: boolean;
+    /**
+     * A callback that fires when the user triggers a change in tooltip visibility.
+     *
+     * `onToggle` is called with the desired next `show`, and generally should be passed
+     * back to the `show` prop. `onToggle` fires _after_ the configured `delay`
+     *
+     * @controllable `show`
+     */
+    onToggle?: (show: boolean) => void;
+};
 declare const OverlayTrigger: {
     (props: PropsWithChildren<OverlayTriggerProps>): import("react/jsx-runtime").JSX.Element;
     TRIGGER_CLICK: "click";

package/components/overlay/OverlayTrigger.js

@@ -1,15 +1,147 @@
-import { jsx as _jsx } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 // @ts-ignore-next-line importsNotUsedAsValues
-import 'react';
-import BSOverlayTrigger from 'react-bootstrap/OverlayTrigger';
-import omit from 'lodash/omit';
+import React, { useCallback, useEffect, useRef, useState } from 'react';
+import ReactDOM from 'react-dom';
+import { usePopper } from 'react-popper';
 import { PLACEMENT } from '../../values/Placement';
 import { TRIGGER } from '../../values/Trigger';
+import mergeRefs from '../../utils/mergeRefs';
+import { useClickOutsideWithRef } from '../../hooks/useClickOutside';
+import { useChainedTimeout } from '../../hooks/useTimeout';
+import { useUncontrolledProp } from '../../hooks/useUncontrollable';
 const OverlayTrigger = (props) => {
-    const usedProps = Object.assign({ rootClose: true }, omit(props, 'children'));
-    const { children } = props;
-    // @ts-ignore
-    return _jsx(BSOverlayTrigger, Object.assign({}, usedProps, { children: children }));
+    var _a, _b;
+    const { show: propsShow, defaultShow = false, enablePortal = true, trigger = TRIGGER.HOVER, delay, overlay, placement = 'top', popperConfig, onToggle = () => { }, rootClose = true, children, } = props;
+    // Use a hook to handle controlled props that work in pairs like in this case the "show"  and "onToggle"
+    // props. It returns a setter function that automatically triggers the callback.
+    const [show, setShow] = useUncontrolledProp(propsShow, defaultShow, onToggle);
+    const hoverStateRef = useRef('');
+    const timeout = useChainedTimeout();
+    const { onFocus, onBlur, onClick } = typeof children !== 'function' ? React.Children.only(children).props : {};
+    // Simple implementation of mouseEnter and mouseLeave.
+    // React's built version is broken: https://github.com/facebook/react/issues/4251
+    // for cases when the trigger is disabled and mouseOut/Over can cause flicker
+    // moving from one child element to another.
+    const handleMouseOverOut = (handler, args, relatedNative) => {
+        const [event] = args;
+        const target = event.currentTarget;
+        const related = event.relatedTarget;
+        if ((!related || related !== target) && !target.contains(related)) {
+            handler(...args);
+        }
+    };
+    const handleShow = () => {
+        timeout.clear();
+        hoverStateRef.current = 'show';
+        if (typeof delay === 'number' || !(delay === null || delay === void 0 ? void 0 : delay.show)) {
+            setShow(true);
+            return;
+        }
+        timeout.set(() => {
+            if (hoverStateRef.current === 'show') {
+                setShow(true);
+            }
+        }, typeof delay === 'number' ? delay : delay === null || delay === void 0 ? void 0 : delay.show);
+    };
+    const handleHide = () => {
+        timeout.clear();
+        hoverStateRef.current = 'hide';
+        if (typeof delay === 'number' || !(delay === null || delay === void 0 ? void 0 : delay.hide)) {
+            setShow(false);
+            return;
+        }
+        timeout.set(() => {
+            if (hoverStateRef.current === 'hide') {
+                setShow(false);
+            }
+        }, typeof delay === 'number' ? delay : delay === null || delay === void 0 ? void 0 : delay.hide);
+    };
+    const handleFocus = useCallback((...args) => {
+        handleShow();
+        onFocus === null || onFocus === void 0 ? void 0 : onFocus(...args);
+    }, [handleShow, onFocus]);
+    const handleBlur = useCallback((...args) => {
+        handleHide();
+        onBlur === null || onBlur === void 0 ? void 0 : onBlur(...args);
+    }, [handleHide, onBlur]);
+    const handleClick = useCallback((...args) => {
+        setShow(!show);
+        onClick === null || onClick === void 0 ? void 0 : onClick(...args);
+    }, [onClick, setShow, show]);
+    const handleMouseOver = useCallback((...args) => {
+        handleMouseOverOut(handleShow, args, 'fromElement');
+    }, [handleShow]);
+    const handleMouseOut = useCallback((...args) => {
+        handleMouseOverOut(handleHide, args, 'toElement');
+    }, [handleHide]);
+    const [triggerNode, setTriggerNode] = useState(null);
+    const [popperElement, setPopperElement] = useState(null);
+    const [arrowElement, setArrowElement] = useState(null);
+    const [arrowPlacement, setArrowPlacement] = useState(placement);
+    const handleClickOutside = useCallback((event) => {
+        const isToggleTarget = triggerNode === null || triggerNode === void 0 ? void 0 : triggerNode.contains(event.target);
+        const isOverlayTarget = popperElement === null || popperElement === void 0 ? void 0 : popperElement.contains(event.target);
+        // Check if the click occurred outside the trigger element. Clicking on the trigger
+        // itself is handled by the onClick handler
+        if (show && rootClose && !isToggleTarget && !isOverlayTarget) {
+            handleHide();
+        }
+    }, [triggerNode, popperElement, rootClose, handleHide]);
+    useClickOutsideWithRef(triggerNode, handleClickOutside);
+    const triggerProps = {
+        ref: mergeRefs([children.ref, setTriggerNode]),
+    };
+    if (trigger === 'click') {
+        triggerProps.onClick = handleClick;
+    }
+    else if (trigger === 'focus') {
+        triggerProps.onFocus = handleFocus;
+        triggerProps.onBlur = handleBlur;
+    }
+    else if (trigger === 'hover') {
+        triggerProps.onMouseOver = handleMouseOver;
+        triggerProps.onMouseOut = handleMouseOut;
+    }
+    const defaultPopperConfig = {
+        placement,
+        modifiers: [
+            {
+                name: 'arrow',
+                options: {
+                    element: arrowElement,
+                },
+            },
+            {
+                name: 'flip',
+                options: {
+                    fallbackPlacements: ['right', 'left', 'top'],
+                },
+            },
+        ],
+    };
+    if (popperConfig) {
+        popperConfig.placement = placement;
+        // if it has an arrow modifier, inject the arrow element
+        const updatedModifiers = [];
+        (_a = popperConfig.modifiers) === null || _a === void 0 ? void 0 : _a.forEach((mod) => {
+            if (mod.name !== 'arrow') {
+                return updatedModifiers.push(mod);
+            }
+            return updatedModifiers.push(Object.assign(Object.assign({}, mod), { options: Object.assign(Object.assign({}, mod.options), { element: arrowElement }) }));
+        });
+        popperConfig.modifiers = updatedModifiers;
+    }
+    const popper = usePopper(triggerNode, popperElement, popperConfig || defaultPopperConfig);
+    // In case the overlay causes an overflow and the "flip" modifier
+    // changes the overlays placement, we nee to update the arrow placement as well
+    useEffect(() => {
+        if (popper.state) {
+            // Adjust arrow styles based on placement if necessary
+            setArrowPlacement(popper.state.placement);
+        }
+    }, [(_b = popper.state) === null || _b === void 0 ? void 0 : _b.placement]);
+    const overlayElement = React.cloneElement(overlay, Object.assign(Object.assign({}, popper.attributes.popper), { ref: setPopperElement, placement: arrowPlacement, style: Object.assign({}, popper.styles.popper), arrowProps: Object.assign(Object.assign({}, popper.attributes.arrow), { style: popper.styles.arrow, ref: setArrowElement }) }));
+    return (_jsxs(_Fragment, { children: [show && (enablePortal ? ReactDOM.createPortal(overlayElement, document.body) : overlayElement), React.cloneElement(children, triggerProps)] }));
 };
 OverlayTrigger.TRIGGER_CLICK = TRIGGER.CLICK;
 OverlayTrigger.TRIGGER_HOVER = TRIGGER.HOVER;