@adaptabletools/adaptable 21.2.2-canary.0 → 22.0.0-canary.0

package/src/components/DragAndDropContext/DragAndDropContext.d.ts

@@ -3,5 +3,5 @@ import { ModuleManagerProps } from './ModuleManager';
 import { ModuleDraggableItem } from './types';
 export declare const DragAndDropContext: React.Context<{
     availableItems: ModuleDraggableItem[];
-    permittedActions: ModuleManagerProps['permittedActions'];
+    permittedActions: ModuleManagerProps["permittedActions"];
 }>;

package/src/components/DragAndDropContext/ModuleManager.d.ts

@@ -2,6 +2,7 @@ import * as React from 'react';
 import { BaseModuleTab, ModuleDraggableItem } from './types';
 export interface ModuleManagerProps {
     availableItems: ModuleDraggableItem[];
+    className?: string;
     disabled: boolean;
     onTabsChange: (tabs: BaseModuleTab[]) => void;
     tabs: BaseModuleTab[];

package/src/components/DragAndDropContext/ModuleManager.js

@@ -1,12 +1,13 @@
 import * as React from 'react';
 import { DragDropContext } from '../dnd';
-import { PanelWithButton } from '../../View/Components/Panels/PanelWithButton';
-import SimpleButton from '../SimpleButton';
 import { DragAndDropContext } from './DragAndDropContext';
 import { TabList } from './TabList';
 import { UnusedPanel } from './UnusedPanel';
+import { Flex } from '../Flex';
+import clsx from 'clsx';
+import { Card } from '../Card';
 export const ModuleManager = (props) => {
-    const { availableItems, tabs, onTabsChange, tabsTitle, disabled, unusedPanelTitle, dragItemText, permittedActions, } = props;
+    const { availableItems, tabs, onTabsChange, tabsTitle, disabled, unusedPanelTitle, dragItemText, permittedActions, className, } = props;
     const contextValue = React.useMemo(() => {
         const preparedPermittedAction = {
             createTab: true,
@@ -82,8 +83,10 @@ export const ModuleManager = (props) => {
                 handleToolbarDragEnd(result);
         } },
         React.createElement(DragAndDropContext.Provider, { value: contextValue },
-            React.createElement("div", { className: "ab-ModuleSelector", style: { display: 'flex', flexDirection: 'column' } },
+            React.createElement(Flex, { flexDirection: "column", className: clsx('ab-ModuleSelector twa:flex-1', className) },
                 React.createElement(UnusedPanel, { title: unusedPanelTitle, disabled: disabled, items: unusedItems, dragItemText: dragItemText }),
-                React.createElement(PanelWithButton, { className: "ab-ModuleSelector-UsedPanel", headerText: tabsTitle, button: contextValue.permittedActions.createTab && (React.createElement(SimpleButton, { disabled: disabled, onClick: handleTabAdd }, "Add Tab")) },
-                    React.createElement(TabList, { disabled: disabled, tabs: tabs, onRemoveTab: handleRemoveTab, onRemoveToolbar: handleRemoveToolbar, onChangeTabName: handleChangeTabName }))))));
+                React.createElement(Card, { className: "twa:flex-1 twa:m-2 ab-ModuleSelector-UsedPanel" },
+                    React.createElement(Card.Title, { border: false }, tabsTitle),
+                    React.createElement(Card.Body, { className: "twa:px-2" },
+                        React.createElement(TabList, { disabled: disabled, tabs: tabs, onRemoveTab: handleRemoveTab, onRemoveToolbar: handleRemoveToolbar, onChangeTabName: handleChangeTabName, onNewTab: contextValue.permittedActions.createTab ? handleTabAdd : undefined })))))));
 };

package/src/components/DragAndDropContext/TabList.d.ts

@@ -1,11 +1,12 @@
 import * as React from 'react';
 import { BaseModuleTab } from './types';
-export declare function TabList({ tabs, onRemoveTab, onRemoveToolbar, onChangeTabName, disabled, }: {
+export declare function TabList({ tabs, onRemoveTab, onRemoveToolbar, onChangeTabName, disabled, onNewTab, }: {
     disabled: boolean;
     tabs: BaseModuleTab[];
     onRemoveTab: (tabIndex: number) => void;
     onRemoveToolbar: (tabIndex: number, toolbarIndex: number) => void;
     onChangeTabName: (tabIndex: number, tabName: string) => void;
+    onNewTab?: () => void;
 }): React.JSX.Element;
 export declare function TabItem({ tab, tabIndex, onRemove, onRemoveToolbar, onChangeTabName, disabled, }: {
     tab: BaseModuleTab;

package/src/components/DragAndDropContext/TabList.js

@@ -1,45 +1,65 @@
 import * as React from 'react';
 import { Draggable, Droppable } from '../dnd';
-import { Box, Flex } from 'rebass';
 import { Icon } from '../icons';
 import SimpleButton from '../SimpleButton';
 import { DragAndDropContext } from './DragAndDropContext';
-export function TabList({ tabs, onRemoveTab, onRemoveToolbar, onChangeTabName, disabled, }) {
-    return (React.createElement(Droppable, { droppableId: "MAIN", type: "TAB", direction: "horizontal" }, (provided) => (React.createElement("div", { ...provided.droppableProps, className: "ab-ModuleSelector__TabList", ref: provided.innerRef, style: { display: 'flex' }, "data-name": "dashboard-tabs" },
+import { Box, Flex } from '../Flex';
+export function TabList({ tabs, onRemoveTab, onRemoveToolbar, onChangeTabName, disabled, onNewTab, }) {
+    return (React.createElement(Droppable, { droppableId: "MAIN", type: "TAB", direction: "horizontal" }, (provided) => (React.createElement("div", { ...provided.droppableProps, className: "ab-ModuleSelector__TabList twa:flex twa:flex-1 twa:overflow-auto", ref: provided.innerRef, "data-name": "dashboard-tabs" },
         tabs.map((tab, tabIndex) => (React.createElement(TabItem, { disabled: disabled, key: tabIndex, tabIndex: tabIndex, tab: tab, onRemove: () => onRemoveTab(tabIndex), onRemoveToolbar: (toolbarIndex) => onRemoveToolbar(tabIndex, toolbarIndex), onChangeTabName: (tabName) => onChangeTabName(tabIndex, tabName) }))),
+        !disabled && onNewTab ? (React.createElement(Flex, { alignItems: "center", justifyContent: "center", className: "ab-ModuleSelector__TabItem twa:min-w-32 twa:border-dashed twa:cursor-pointer twa:bg-primarylight twa:text-primary-foreground twa:hover:bg-primary", onClick: onNewTab },
+            React.createElement("div", { className: "twa:text-8 twa:flex twa:flex-col twa:gap-4 twa:items-center twa:italic" },
+                React.createElement(Icon, { name: "plus", size: 32 }),
+                "Click to add tab"))) : null,
         provided.placeholder))));
 }
 export function TabItem({ tab, tabIndex, onRemove, onRemoveToolbar, onChangeTabName, disabled, }) {
     const context = React.useContext(DragAndDropContext);
     const isDragDisabled = disabled || !context.permittedActions.dragAndDropTab;
-    return (React.createElement(Draggable, { isDragDisabled: isDragDisabled, draggableId: String(tabIndex), index: tabIndex }, (provided) => (React.createElement("div", { className: "ab-ModuleSelector__TabItem", "data-name": "dashboard-tab", ref: provided.innerRef, ...provided.draggableProps, style: {
-            ...(isDragDisabled ? {} : provided.draggableProps.style),
-        } },
-        React.createElement("div", { className: "ab-ModuleSelector__TabItem__header" },
-            React.createElement("div", { ...(disabled ? {} : provided.dragHandleProps), style: context.permittedActions.dragAndDropTab
-                    ? {}
-                    : {
-                        display: 'none',
-                    } },
-                React.createElement(Icon, { name: "drag" })),
-            context.permittedActions.editTabName ? (React.createElement("input", { className: "ab-ModuleSelector__TabItem__header-input", type: "text", disabled: disabled, value: tab.Name, onChange: (event) => {
-                    onChangeTabName(event.target.value);
-                } })) : (tab.Name),
-            context.permittedActions.deleteTab && (React.createElement(SimpleButton, { disabled: disabled, icon: "delete", variant: "text", onClick: onRemove }))),
-        React.createElement(ToolbarList, { disabled: disabled, toolbars: tab.Items, droppableId: String(tabIndex), onRemove: onRemoveToolbar })))));
+    return (React.createElement(Draggable, { isDragDisabled: isDragDisabled, draggableId: String(tabIndex), index: tabIndex }, (provided) => {
+        let showHeader = true;
+        if (tab.Name === '' &&
+            !context.permittedActions.editTabName &&
+            !context.permittedActions.deleteTab) {
+            showHeader = false;
+        }
+        return (React.createElement("div", { className: "ab-ModuleSelector__TabItem twa:min-w-32", "data-name": "dashboard-tab", ref: provided.innerRef, ...provided.draggableProps, style: {
+                ...(isDragDisabled ? {} : provided.draggableProps.style),
+            } },
+            showHeader ? (React.createElement("div", { className: "ab-ModuleSelector__TabItem__header" },
+                React.createElement("div", { ...(disabled ? {} : provided.dragHandleProps), style: context.permittedActions.dragAndDropTab
+                        ? {}
+                        : {
+                            display: 'none',
+                        } },
+                    React.createElement(Icon, { name: "drag" })),
+                context.permittedActions.editTabName ? (React.createElement("input", { className: "ab-ModuleSelector__TabItem__header-input", type: "text", disabled: disabled, value: tab.Name, onChange: (event) => {
+                        onChangeTabName(event.target.value);
+                    } })) : (tab.Name),
+                context.permittedActions.deleteTab && (React.createElement(SimpleButton, { disabled: disabled, icon: "delete", variant: "text", onClick: onRemove })))) : null,
+            React.createElement(ToolbarList, { disabled: disabled, toolbars: tab.Items, droppableId: String(tabIndex), onRemove: onRemoveToolbar })));
+    }));
 }
 export function ToolbarList({ toolbars, droppableId, onRemove, disabled, }) {
-    return (React.createElement(Droppable, { droppableId: droppableId, type: "TOOLBAR" }, (provided, snapshot) => (React.createElement(Box, { className: "ab-ModuleSelector__ToolbarList", ref: provided.innerRef, ...(disabled ? {} : provided.droppableProps), "data-name": "dashboard-toolbar-drop-target", backgroundColor: snapshot.isDraggingOver ? 'var(--ab-dashboard-tab-drop-target__background)' : '' },
+    return (React.createElement(Droppable, { droppableId: droppableId, type: "TOOLBAR" }, (provided, snapshot) => (React.createElement(Box, { className: "ab-ModuleSelector__ToolbarList", ref: provided.innerRef, ...(disabled ? {} : provided.droppableProps), "data-name": "dashboard-toolbar-drop-target", style: {
+            backgroundColor: snapshot.isDraggingOver
+                ? 'var(--ab-dashboard-tab-drop-target__background)'
+                : '',
+        } },
         toolbars?.map((toolbar, toolbarIndex) => (React.createElement(ToolbarItem, { disabled: disabled, key: toolbar, toolbar: toolbar, toolbarIndex: toolbarIndex, onRemove: () => onRemove(toolbarIndex) }))),
+        toolbars.length === 0 ? (React.createElement("div", { className: "ab-ModuleSelector__ToolbarList__placeholder twa:flex twa:items-center twa:justify-center twa:h-full twa:italic twa:text-center" }, "Drag and drop toolbar here")) : null,
         provided.placeholder))));
 }
 export function ToolbarItem({ toolbar, toolbarIndex, onRemove, disabled, }) {
     const { availableItems } = React.useContext(DragAndDropContext);
     let currentItem = availableItems.find((t) => t.Id === toolbar);
     const title = currentItem ? currentItem.Title : toolbar;
-    return (React.createElement(Draggable, { isDragDisabled: disabled, draggableId: toolbar, index: toolbarIndex }, (provided, snapshot) => (React.createElement(Flex, { className: "ab-ModuleSelector__ToolbarItem", alignItems: "center", mb: 1, pl: 1, backgroundColor: snapshot.isDragging
-            ? 'var(--ab-dashboard-toolbar-drag__background)'
-            : 'var(--ab-color-primarylight)', ref: provided.innerRef, ...provided.draggableProps, ...provided.dragHandleProps, style: provided.draggableProps.style },
-        React.createElement("div", { style: { flex: 1 } }, title),
-        React.createElement(SimpleButton, { disabled: disabled, icon: "close", variant: "text", padding: 1, onClick: onRemove })))));
+    return (React.createElement(Draggable, { isDragDisabled: disabled, draggableId: toolbar, index: toolbarIndex }, (provided, snapshot) => (React.createElement(Flex, { className: `ab-ModuleSelector__ToolbarItem twa:mb-1 twa:pl-1`, alignItems: "center", ref: provided.innerRef, ...provided.draggableProps, ...provided.dragHandleProps, style: {
+            ...provided.draggableProps.style,
+            backgroundColor: snapshot.isDragging
+                ? 'var(--ab-dashboard-toolbar-drag__background)'
+                : 'var(--ab-color-primarylight)',
+        } },
+        React.createElement("div", { className: "twa:flex-1" }, title),
+        React.createElement(SimpleButton, { disabled: disabled, icon: "close", variant: "text", className: "twa:p-1", onClick: onRemove })))));
 }

package/src/components/DragAndDropContext/UnusedPanel.js

@@ -1,10 +1,11 @@
 import * as React from 'react';
 import { Draggable, Droppable } from '../dnd';
-import { Box } from 'rebass';
 import { DragAndDropContext } from './DragAndDropContext';
+import { Box } from '../Flex';
+import clsx from 'clsx';
 export function UnusedPanel({ items, disabled, title, dragItemText, }) {
-    return (React.createElement(Box, { pb: 1, mb: 2, className: "ab-ModuleSelector__UnusedPanel", "data-name": "unusedpanel-items" },
-        React.createElement(Box, { p: 2 },
+    return (React.createElement(Box, { className: "ab-ModuleSelector__UnusedPanel twa:mb-2 twa:pb-1", "data-name": "unusedpanel-items" },
+        React.createElement(Box, { className: "twa:p-2" },
             React.createElement("b", null, title),
             " (",
             dragItemText,
@@ -12,13 +13,7 @@ export function UnusedPanel({ items, disabled, title, dragItemText, }) {
         React.createElement(UnusedItemList, { disabled: disabled, items: items })));
 }
 function UnusedItemList({ items, disabled }) {
-    return (React.createElement(Droppable, { droppableId: "UNUSED", type: "TOOLBAR", isDropDisabled: true, direction: "horizontal" }, (provided) => (React.createElement("div", { ref: provided.innerRef, "data-name": "unusedpanel-items-list", ...provided.droppableProps, style: {
-            display: 'flex',
-            flexDirection: 'row',
-            flexWrap: 'wrap',
-            paddingLeft: 'var(--ab-space-2)',
-            paddingRight: 'var(--ab-space-2)',
-        } },
+    return (React.createElement(Droppable, { droppableId: "UNUSED", type: "TOOLBAR", isDropDisabled: true, direction: "horizontal" }, (provided) => (React.createElement("div", { ref: provided.innerRef, "data-name": "unusedpanel-items-list", ...provided.droppableProps, className: 'twa:px-2 twa:flex-wrap twa:flex twa:flex-row twa:gap-1' },
         items.map((unusedItem, unusedItemIndex) => (React.createElement(UnusedItem, { disabled: disabled, key: unusedItem, unusedItem: unusedItem, unusedItemIndex: unusedItemIndex }))),
         provided.placeholder))));
 }
@@ -34,15 +29,12 @@ function UnusedItem({ unusedItem, unusedItemIndex, disabled, }) {
                 ...provided.dragHandleProps,
             };
         const dragStyle = disabled ? {} : provided.draggableProps.style;
-        return (React.createElement("div", { "data-name": "unused-item", ref: provided.innerRef, ...eventHandlers, style: {
+        return (React.createElement("div", { "data-name": "unused-item", ref: provided.innerRef, ...eventHandlers, className: clsx('twa:rounded-md twa:text-sm twa:text-text-on-primary twa:p-2'), style: {
                 ...dragStyle,
                 border: '1px solid var(--ab-color-primary)',
                 backgroundColor: snapshot.isDragging
                     ? 'var(--ab-dashboard-toolbar-drag__background)'
-                    : 'var(--ab-color-primarylight)',
-                padding: 'var(--ab-space-1) var(--ab-space-2)',
-                marginRight: 'var(--ab-space-1)',
-                marginBottom: 'var(--ab-space-1)',
+                    : 'var(--ab-color-primary)',
             } }, title));
     }));
 }

package/src/components/Dropdown/index.d.ts

@@ -1,11 +1,11 @@
 import * as React from 'react';
 import { ReactNode } from 'react';
-import { BoxProps } from 'rebass';
+import { FlexProps } from '../Flex';
 export type DropdownOption = {
     label: string;
     value: string;
 };
-export type DropdownProps = Omit<BoxProps, 'onChange' | 'value'> & {
+export type DropdownProps = Omit<FlexProps & React.HTMLProps<HTMLDivElement>, 'onChange' | 'value' | 'as' | 'flexDirection' | 'alignItems' | 'height' | 'size'> & {
     autoFocus?: boolean;
     expanded?: boolean;
     disabled?: boolean;

package/src/components/Dropdown/index.js

@@ -1,10 +1,11 @@
 import * as React from 'react';
 import { useState, useRef } from 'react';
-import { Flex } from 'rebass';
 import join from '../utils/join';
 import useProperty from '../utils/useProperty';
 import Arrows from './Arrows';
 import SimpleButton from '../SimpleButton';
+import { Flex } from '../Flex';
+import { twMerge } from '../../twMerge';
 const baseClassName = 'ab-Dropdown';
 const Dropdown = (props) => {
     let { options, multiple, name, autoFocus, showEmptyItem = true, showClearButton, disabled, allowSearch, clearButtonProps, value: _, onChange: __, style, onExpand, ...boxProps } = props;
@@ -76,16 +77,14 @@ const Dropdown = (props) => {
         selectedText = placeholder;
     }
     //20  ... 20 16
-    const renderClearButton = () => (React.createElement(SimpleButton, { variant: "text", icon: "close", tone: "none", tooltip: "Clear", iconSize: 20, px: 0, py: 0, marginRight: 1, ...clearButtonProps, style: {
-            zIndex: 10,
-            color: 'inherit',
+    const renderClearButton = () => (React.createElement(SimpleButton, { variant: "text", icon: "close", tone: "none", tooltip: "Clear", iconSize: 20, ...clearButtonProps, className: twMerge('twa:p-0 twa:mr-1 twa:z-10 twa:color-inherit', clearButtonProps.className), style: {
             ...(clearButtonProps ? clearButtonProps.style : null),
         }, onClick: (e) => {
             e.preventDefault();
             onChange(null, e);
         } }));
-    return (React.createElement(Flex, { ref: domRef, flexDirection: "row", alignItems: "center", ...boxProps, className: join(props.className, baseClassName, !selectedOption ? `${baseClassName}--empty` : `${baseClassName}--not-empty`, focused ? `${baseClassName}--focused` : `${baseClassName}--not-focused`, disabled ? `${baseClassName}--disabled` : null), style: style, tabIndex: focused ? -1 : props.tabIndex || 0, onFocus: onFocus, onBlur: onBlur },
-        React.createElement("div", { style: { display: 'inline-block' }, className: `${baseClassName}__text` },
+    return (React.createElement(Flex, { ref: domRef, flexDirection: 'row', alignItems: "center", ...boxProps, className: join(props.className, baseClassName, !selectedOption ? `${baseClassName}--empty` : `${baseClassName}--not-empty`, focused ? `${baseClassName}--focused` : `${baseClassName}--not-focused`, disabled ? `${baseClassName}--disabled` : null), style: style, tabIndex: focused ? -1 : props.tabIndex || 0, onFocus: onFocus, onBlur: onBlur },
+        React.createElement("div", { className: `${baseClassName}__text twa:inline-block` },
             selectedText,
             React.createElement(Arrows, null)),
         React.createElement("select", { ref: selectRef, tabIndex: -1, disabled: disabled, value: value == null ? '' : value, onChange: (e) => {

package/src/components/DropdownButton/index.d.ts

@@ -1,9 +1,9 @@
 import * as React from 'react';
-import { BoxProps } from 'rebass';
 import { SimpleButtonProps } from '../SimpleButton';
 import { ExpandedProps } from './useExpanded';
 import DropdownButtonItem from './DropdownButtonItem';
 import { OverlayTriggerProps } from '../OverlayTrigger';
+import { BoxProps } from '../Flex';
 export declare const DROPDOWN_ICON: React.JSX.Element;
 export type DropdownButtonProps = React.PropsWithChildren<Omit<BoxProps, 'ref'>> & Omit<React.HTMLProps<HTMLElement>, 'ref'> & SimpleButtonProps & ExpandedProps & {
     collapseOnItemClick?: boolean;
@@ -24,25 +24,5 @@ export type DropdownButtonProps = React.PropsWithChildren<Omit<BoxProps, 'ref'>>
     isItemDisabled?: (item: DropdownButtonItem) => boolean | undefined;
     showToggleIcon?: boolean;
 };
-declare const DropdownButton: React.ForwardRefExoticComponent<Omit<BoxProps, "ref"> & {
-    children?: React.ReactNode;
-} & Omit<React.HTMLProps<HTMLElement>, "ref"> & SimpleButtonProps & ExpandedProps & {
-    collapseOnItemClick?: boolean;
-    columns?: string[];
-    overlayProps?: OverlayTriggerProps;
-    listOffset?: number;
-    items?: DropdownButtonItem[];
-    stopPropagationOnOverlay?: boolean;
-    idProperty?: string;
-    showClearButton?: boolean;
-    focusOnClear?: boolean;
-    onClear?: () => void;
-    clearButtonProps?: SimpleButtonProps;
-    listItemClassName?: string;
-    listStyle?: React.CSSProperties;
-    listMinWidth?: number;
-    listItemStyle?: React.CSSProperties | ((item: DropdownButtonItem, index: number) => React.CSSProperties);
-    isItemDisabled?: (item: DropdownButtonItem) => boolean | undefined;
-    showToggleIcon?: boolean;
-} & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownButton: React.ForwardRefExoticComponent<Omit<React.PropsWithChildren<DropdownButtonProps>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
 export default DropdownButton;

package/src/components/DropdownButton/index.js

@@ -5,9 +5,10 @@ import SimpleButton from '../SimpleButton';
 import useExpanded from './useExpanded';
 import renderItem from './renderItem';
 import OverlayTrigger from '../OverlayTrigger';
+import clsx from 'clsx';
 export const DROPDOWN_ICON = (React.createElement("svg", { width: "20", height: "20", viewBox: "0 0 24 24" },
     React.createElement("path", { d: "M7 10l5 5 5-5H7z" })));
-const spacer = React.createElement("div", { style: { flex: 1 } });
+const spacer = React.createElement("div", { className: "twa:flex-1" });
 const baseClassName = 'ab-DropdownButton';
 const defaultListItemStyle = {
     padding: 'var(--ab-cmp-dropdownbutton-list-item__padding)',
@@ -99,7 +100,7 @@ const DropdownButton = React.forwardRef((props, theRef) => {
                 onClear();
             }
             buttonRef.current?.focus();
-        }, ml: 2, padding: 0, variant: 'text', icon: "close", ...clearButtonProps, style: {
+        }, className: "twa:ml-2 twa:p-0", variant: 'text', icon: "close", ...clearButtonProps, style: {
             ...clearButtonProps?.style,
             visibility: showClearButton ? 'visible' : 'hidden',
         } })) : null;
@@ -120,7 +121,7 @@ const DropdownButton = React.forwardRef((props, theRef) => {
                     }
                 } }, content));
         }, ...overlayProps },
-        React.createElement(SimpleButton, { iconPosition: "end", ...(showToggleIcon && { icon, paddingRight: 0 }), ...domProps, ref: (btn) => {
+        React.createElement(SimpleButton, { iconPosition: "end", ...(showToggleIcon && { icon }), ...domProps, ref: (btn) => {
                 buttonRef.current = btn;
                 if (!theRef) {
                     return;
@@ -131,7 +132,9 @@ const DropdownButton = React.forwardRef((props, theRef) => {
                 else {
                     theRef.current = btn;
                 }
-            }, style: domProps.style, className: className, onClick: (e) => {
+            }, style: domProps.style, className: clsx(className, {
+                'twa:pr-0': showToggleIcon,
+            }), onClick: (e) => {
                 if (domProps.onClick) {
                     domProps.onClick(e);
                 }

package/src/components/EmptyContent/index.d.ts

@@ -1,6 +1,6 @@
 import * as React from 'react';
 import { HTMLProps } from 'react';
-import { FlexProps } from 'rebass';
-type EmptyContentProps = HTMLProps<HTMLElement> & FlexProps & {};
+import { FlexProps } from '../Flex';
+type EmptyContentProps = HTMLProps<HTMLDivElement> & FlexProps & {};
 declare const EmptyContent: ({ children, className, style, ...flexProps }: EmptyContentProps) => React.JSX.Element;
 export default EmptyContent;

package/src/components/EmptyContent/index.js

@@ -1,12 +1,12 @@
 import * as React from 'react';
-import { Box, Flex } from 'rebass';
-import join from '../utils/join';
+import { Box, Flex } from '../Flex';
+import clsx from 'clsx';
 const baseClassName = 'ab-EmptyContent';
 const EmptyContent = ({ children, className, style, ...flexProps }) => {
     if (typeof children === 'string') {
         children = React.createElement("p", null, children);
     }
-    return (React.createElement(Box, { flex: 1, className: `${baseClassName}__wrapper` },
-        React.createElement(Flex, { alignItems: "center", justifyContent: "center", flexDirection: "column", ...flexProps, className: join(baseClassName, className), style: style }, children)));
+    return (React.createElement(Box, { className: `${baseClassName}__wrapper twa:flex-1 twa:relative twa:size-full` },
+        React.createElement(Flex, { alignItems: "center", justifyContent: "center", flexDirection: "column", ...flexProps, className: clsx('twa:absolute twa:inset-0 twa:text-3 twa:text-center twa:p-4', 'twa:[&_p]:text-primary-foreground', baseClassName, className), style: style }, children)));
 };
 export default EmptyContent;

package/src/components/ErrorBox/index.d.ts

@@ -1,5 +1,5 @@
 import * as React from 'react';
-import { BoxProps } from 'rebass';
+import { HTMLProps } from 'react';
 export declare const baseClassName = "ab-ErrorBox";
-declare const ErrorBox: (props: BoxProps) => React.JSX.Element;
+declare const ErrorBox: (props: HTMLProps<HTMLDivElement>) => React.JSX.Element;
 export default ErrorBox;

package/src/components/ErrorBox/index.js

@@ -1,8 +1,8 @@
 import * as React from 'react';
-import { Box } from 'rebass';
-import join from '../utils/join';
+import { Box } from '../Flex';
+import clsx from 'clsx';
 export const baseClassName = 'ab-ErrorBox';
 const ErrorBox = (props) => {
-    return React.createElement(Box, { ...props, className: join(props.className, baseClassName) });
+    return (React.createElement(Box, { ...props, className: clsx('twa:p-3 twa:rounded-standard twa:bg-error twa:text-text-on-error', props.className, baseClassName) }));
 };
 export default ErrorBox;

package/src/components/ExpressionEditor/BaseEditorInput.js

@@ -1,4 +1,3 @@
-import { Box, Flex, Text } from 'rebass';
 import * as parser from '../../parser/src';
 import * as React from 'react';
 import ErrorBox from '../ErrorBox';
@@ -19,6 +18,9 @@ import { ExpressionFunctionDocumentation } from './ExpressionFunctionDocumentati
 import { Tag } from '../Tag';
 import StringExtensions from '../../Utilities/Extensions/StringExtensions';
 import Radio from '../Radio';
+import { Box, Flex } from '../Flex';
+import { AdaptableFormControlTextClear } from '../../View/Components/Forms/AdaptableFormControlTextClear';
+import clsx from 'clsx';
 const filterableCategories = [
     'dates',
     'logical',
@@ -43,7 +45,7 @@ const getCategoryOrder = (category) => {
     };
     return predefinedOrder[category] || 0;
 };
-const VarEditorButton = () => {
+const VarEditorButton = ({ className }) => {
     const adaptable = useAdaptable();
     const customQueryVariables = adaptable.api.optionsApi.getExpressionOptions()?.customQueryVariables;
     if (!customQueryVariables || Object.keys(customQueryVariables).length === 0) {
@@ -51,7 +53,7 @@ const VarEditorButton = () => {
     }
     return (React.createElement(React.Fragment, null, Object.keys(customQueryVariables).map((varOption) => {
         const varString = `VAR('${varOption}')`;
-        return (React.createElement(EditorButton, { data: varString, key: varOption }, varString));
+        return (React.createElement(EditorButton, { data: varString, key: varOption, className: className }, varString));
     })));
 };
 const FunctionsDropdown = ({ expressionFunctions, baseClassName }) => {
@@ -107,54 +109,68 @@ const FunctionsDropdown = ({ expressionFunctions, baseClassName }) => {
         dropdownRef.current.hide();
         setOverFunction(null);
     };
+    const [searchInputValue, setSearchInputValue] = React.useState('');
     /**
      * Hide when:
      * - mouse leaves
      * - a function is inserted
      */
-    return (React.createElement(OverlayTrigger, { ref: dropdownRef, showEvent: "mouseenter", hideEvent: "mouseleave", targetOffset: 5, render: () => (React.createElement(Flex, { className: `${baseClassName}__dropdown-functions-list-wrapper`, flexDirection: "column", onMouseLeave: () => hidePopup() },
-            React.createElement(Flex, { pl: 2, style: { gap: 10 } }, categoryOptions.map((option, index) => {
+    return (React.createElement(OverlayTrigger, { ref: dropdownRef, showEvent: "mouseenter", hideEvent: "mouseleave", targetOffset: 5, render: () => (React.createElement(Flex, { className: `${baseClassName}__dropdown-functions-list-wrapper twa:max-w-[60vw] twa:shadow-md twa:bg-defaultbackground twa:text-text-on-defaultbackground twa:text-3 twa:rounded-standard twa:p-3`, flexDirection: "column", onMouseLeave: () => hidePopup() },
+            React.createElement(Flex, { className: "twa:md:gap-3 twa:gap-2 twa:pb-2 twa:md:justify-between twa:justify-start twa:flex-wrap twa:border-b twa:border-primarydark/30 twa:mb-2" }, categoryOptions.map((option, index) => {
                 return (React.createElement(Radio, { key: option.value, onFocus: (event) => {
                         event.preventDefault();
                         event.stopPropagation();
                     }, onClick: handleFunctionCategoryChange(option.value), checked: currentFunctionCategory === option.value }, option.label));
             })),
-            React.createElement(Flex, null,
-                React.createElement(Flex, { className: `${baseClassName}__dropdown-functions-list`, "data-name": "expression-dropdown-functions-list", flexDirection: "column", p: 2, maxHeight: '50vh' }, orderedGroupNames
-                    .filter((groupName) => !!groupedFunctions[groupName])
-                    .map((groupName) => {
-                    const functionsInGroup = Object.keys(groupedFunctions[groupName]);
-                    if (functionsInGroup.length === 0) {
-                        return React.createElement(React.Fragment, { key: groupName });
-                    }
-                    const getEditorButtonData = (functionName) => {
-                        // handle special cases
-                        if (functionName === 'CASE') {
-                            return `CASE <caseValue> WHEN <whenValue> THEN <thenValue> ELSE <defaultValue> END`;
+            React.createElement(Flex, { className: "twa:gap-2 twa:max-h-[60vh]", flexDirection: "row" },
+                React.createElement(Flex, { flexDirection: "column", className: "twa:gap-2 twa:rounded-standard" },
+                    React.createElement(Box, null,
+                        React.createElement(AdaptableFormControlTextClear, { className: "twa:w-full", value: searchInputValue, OnTextChange: setSearchInputValue, placeholder: "Search Functions" })),
+                    React.createElement(Flex, { className: `${baseClassName}__dropdown-functions-list twa:overflow-auto`, "data-name": "expression-dropdown-functions-list", flexDirection: "column" }, orderedGroupNames
+                        .filter((groupName) => !!groupedFunctions[groupName])
+                        .map((groupName) => {
+                        const functionsInGroup = Object.keys(groupedFunctions[groupName]);
+                        if (functionsInGroup.length === 0) {
+                            return React.createElement(React.Fragment, { key: groupName });
                         }
-                        if (functionName === 'TRUE' || functionName === 'FALSE') {
-                            return functionName;
-                        }
-                        if (functionName === 'IF') {
-                            return `<condition_expr> ? <consequent_expr> : <alternative_expr>`;
-                        }
-                        return `${functionName}()`;
-                    };
-                    return (React.createElement(Box, { mb: 2, key: groupName },
-                        React.createElement(Tag, { mb: 1 }, StringExtensions.Humanize(groupName)),
-                        functionsInGroup.map((functionName) => (React.createElement(Box, { key: functionName, onMouseEnter: () => setOverFunction(functionName), onClick: () => hidePopup() }, functionName === 'VAR' ? (React.createElement(VarEditorButton, { key: functionName })) : (React.createElement(EditorButton, { data: getEditorButtonData(functionName), key: functionName, mr: 1 }, functionName)))))));
-                })),
-                React.createElement(Box, { className: `${baseClassName}__dropdown-functions-description`, p: 2, width: 600, maxWidth: "30vw" }, overFunction ? (React.createElement(React.Fragment, null,
-                    React.createElement(Tag, null, overFunction),
-                    React.createElement(ExpressionFunctionDocumentation, { expressionFunction: expressionFunctions[overFunction] }))) : (React.createElement(Tag, { padding: 20 },
+                        const getEditorButtonData = (functionName) => {
+                            // handle special cases
+                            if (functionName === 'CASE') {
+                                return `CASE <caseValue> WHEN <whenValue> THEN <thenValue> ELSE <defaultValue> END`;
+                            }
+                            if (functionName === 'TRUE' || functionName === 'FALSE') {
+                                return functionName;
+                            }
+                            if (functionName === 'IF') {
+                                return `<condition_expr> ? <consequent_expr> : <alternative_expr>`;
+                            }
+                            return `${functionName}()`;
+                        };
+                        const fns = functionsInGroup
+                            .map((functionName) => {
+                            if (searchInputValue &&
+                                !functionName.toLowerCase().includes(searchInputValue.toLowerCase())) {
+                                return null;
+                            }
+                            const buttonClassName = 'twa:mr-1 twa:hover:bg-accent twa:hover:text-accent-foreground';
+                            return (React.createElement(Box, { key: functionName, onMouseEnter: () => setOverFunction(functionName), onClick: () => hidePopup() }, functionName === 'VAR' ? (React.createElement(VarEditorButton, { key: functionName, className: buttonClassName })) : (React.createElement(EditorButton, { data: getEditorButtonData(functionName), key: functionName, className: buttonClassName }, functionName))));
+                        })
+                            .filter(Boolean);
+                        return (React.createElement(Box, { className: clsx('twa:mb-2 twa:mx-1', fns.length === 0 ? 'twa:hidden' : ''), key: groupName },
+                            React.createElement(Tag, { className: "twa:mb-1 twa:bg-primarylight twa:text-text-on-primary twa:w-full" }, StringExtensions.Humanize(groupName)),
+                            fns));
+                    }))),
+                React.createElement(Box, { className: clsx(`${baseClassName}__dropdown-functions-description `, `twa:flex-1 twa:p-2 twa:w-[600px] twa:max-w-[60vw]`, `twa:rounded-standard twa:shadow-sm twa:overflow-auto twa:h-auto`, 'twa:bg-primarylight twa:text-primary-foreground') }, overFunction ? (React.createElement(React.Fragment, null,
+                    React.createElement(Tag, { className: "twa:bg-accent twa:text-accent-foreground" }, overFunction),
+                    React.createElement(ExpressionFunctionDocumentation, { expressionFunction: expressionFunctions[overFunction] }))) : (React.createElement(Flex, { className: "twa:size-full twa:items-center twa:justify-center twa:text-2 twa:italic" },
                     React.createElement("ul", null,
                         React.createElement("li", null,
                             "Hover over a Function to learn more",
                             React.createElement("br", null),
                             React.createElement("br", null)),
-                        React.createElement("li", null, "Select a Function to add to the Expression in the Editor")))))))) },
-        React.createElement(SimpleButton, { "data-name": "expression-dropdown", icon: "arrow-down", iconPosition: 'end', mr: 1 },
-            React.createElement(Flex, { marginRight: 1, fontSize: 2 },
+                        React.createElement("li", null, "Click a Function to add it to the Expression in the Editor")))))))) },
+        React.createElement(SimpleButton, { "data-name": "expression-dropdown", icon: "arrow-down", iconPosition: 'end', className: "twa:mr-1" },
+            React.createElement(Flex, { className: "twa:mr-1 twa:text-2" },
                 React.createElement(Icon, { name: "equation" })))));
 };
 export function BaseEditorInput(props) {
@@ -173,10 +189,10 @@ export function BaseEditorInput(props) {
         }
         const parserExceptionDetails = e.message;
         return (React.createElement("details", null,
-            React.createElement(Flex, { marginBottom: 1, as: "summary" },
+            React.createElement(Flex, { className: "twa:mb-1", as: "summary" },
                 parserExceptionSummary,
                 React.createElement("i", null, " (click for more details)")),
-            React.createElement(Text, { marginLeft: 3, style: { fontStyle: 'italic' } }, parserExceptionDetails)));
+            React.createElement(Box, { className: "twa:ml-3 twa:italic" }, parserExceptionDetails)));
     };
     const testRowNode = useMemo(() => {
         const firstRowNode = props.api.gridApi.getFirstRowNode();
@@ -239,24 +255,25 @@ export function BaseEditorInput(props) {
         .map((editorButtonDef) => (React.createElement(EditorButton, { key: `${editorButtonDef.functionName}-operator`, data: editorButtonDef.data, icon: editorButtonDef.icon }, !editorButtonDef.icon && (editorButtonDef.text || editorButtonDef.functionName))));
     const showDocumentationLink = props.api.internalApi.isDocumentationLinksDisplayed();
     return (React.createElement(React.Fragment, null,
-        React.createElement(Flex, { className: baseClassName, "data-name": "expression-toolbar", py: 2, mb: 2, mt: 2, flexWrap: "wrap" },
-            React.createElement(Flex, { style: { flex: 1, marginLeft: 5 }, flexWrap: "wrap" },
+        React.createElement(Flex, { "data-name": "expression-toolbar", className: `${baseClassName} twa:py-2 twa:mb-2 twa:mt-2 twa:flex-wrap twa:w-full` },
+            React.createElement(Flex, { className: "twa:flex-1 twa:ml-1 twa:flex-wrap" },
                 React.createElement(FunctionsDropdown, { expressionFunctions: expressionFunctions, baseClassName: baseClassName }),
                 operatorButtons),
             showDocumentationLink && (React.createElement(Flex, { alignItems: "flex-start" },
-                React.createElement(ButtonInfo, { mr: 2, tooltip: 'Learn how to use the Expression Editor', onClick: () => window.open(ExpressionEditorDocsLink, '_blank') })))),
+                React.createElement(ButtonInfo, { className: "twa:mr-2", tooltip: 'Learn how to use the Expression Editor', onClick: () => window.open(ExpressionEditorDocsLink, '_blank') })))),
         React.createElement(Textarea, { "data-name": `expression-input-${type}`, ref: textAreaRefCallback, value: props.value || '', placeholder: props.placeholder || 'Create Query', disabled: props.disabled || false, className: join('ab-ExpressionEditor__textarea', // left for backwards compatibility
-            `${baseClassName}__textarea`), autoFocus: true, spellCheck: "false", onChange: (event) => {
+            `${baseClassName}__textarea`, 'twa:w-full twa:min-h-[100px] twa:p-2 twa:text-4 twa:resize-y twa:font-mono'), autoFocus: true, spellCheck: "false", onChange: (event) => {
                 props.onChange(event.target.value);
             }, style: style }),
-        props.isFullExpression !== true && (React.createElement(HelpBlock, { mt: 2, mb: 2, p: 2, fontSize: 3 },
+        props.isFullExpression !== true && (React.createElement(HelpBlock, { className: "twa:my-2 twa:p-2 twa:text-3" },
             "This Expression must resolve to a ",
             React.createElement("b", null, "boolean "),
             "(i.e. true / false) value")),
-        expressionError && (React.createElement(ErrorBox, { width: "100%", style: { whiteSpace: 'pre-wrap' }, mt: 2 }, expressionError)),
-        evaluationError && (React.createElement(ErrorBox, { style: { whiteSpace: 'pre-wrap' }, mt: 2 }, `${evaluationError.expressionFnName} ${evaluationError.message}`)),
-        !props.hideResultPreview && result !== undefined && (React.createElement(Box, { className: `${baseClassName}__editor-feedback`, "data-name": "expression-editor-feedback", mt: 2, p: 2 },
-            React.createElement("pre", { style: { whiteSpace: 'pre-wrap', margin: 0 } },
-                "Result (using Test Data): ",
-                React.createElement("b", null, JSON.stringify(result)))))));
+        expressionError && (React.createElement(ErrorBox, { className: "twa:mt-2 twa:whitespace-pre-wrap twa:w-full" }, expressionError)),
+        evaluationError && (React.createElement(ErrorBox, { className: "twa:mt-2 twa:whitespace-pre-wrap" }, `${evaluationError.expressionFnName} ${evaluationError.message}`)),
+        !props.hideResultPreview && result !== undefined && (React.createElement(Box, { className: `${baseClassName}__editor-feedback twa:mt-2 twa:p-2 twa:rounded-standard`, "data-name": "expression-editor-feedback" },
+            React.createElement("pre", { className: "twa:whitespace-pre-wrap twa:m-0" },
+                "Result (using test data):",
+                ' ',
+                React.createElement("b", { className: "twa:bg-accentlight twa:text-accent twa:rounded-full twa:p-1 twa:px-2" }, JSON.stringify(result)))))));
 }