@mantine/core 9.2.1 → 9.3.0

package/lib/components/Menu/MenuSearch/MenuSearch.d.ts

@@ -0,0 +1,19 @@
+import { ElementProps, Factory } from '../../../core';
+import { InputProps } from '../../Input/Input';
+export type MenuSearchStylesNames = 'search';
+export interface MenuSearchProps extends InputProps, ElementProps<'input', 'size'> {
+    /** If set, clears the search value after the menu close transition completes. Requires a controlled `value`/`onChange` pair. @default true */
+    clearSearchOnClose?: boolean;
+}
+export type MenuSearchFactory = Factory<{
+    props: MenuSearchProps;
+    ref: HTMLInputElement;
+    stylesNames: MenuSearchStylesNames;
+    compound: true;
+}>;
+export declare const MenuSearch: import("../../..").MantineComponent<{
+    props: MenuSearchProps;
+    ref: HTMLInputElement;
+    stylesNames: MenuSearchStylesNames;
+    compound: true;
+}>;

package/lib/components/Menu/MenuSelectableItem/MenuSelectableItem.d.ts

@@ -0,0 +1,20 @@
+import { MantineColor } from '../../../core';
+export interface MenuSelectableItemProps {
+    role: 'menuitemcheckbox' | 'menuitemradio';
+    checked: boolean;
+    indicator: React.ReactNode;
+    onSelect: () => void;
+    color: MantineColor | undefined;
+    closeMenuOnClick: boolean | undefined;
+    rightSection: React.ReactNode;
+    children: React.ReactNode;
+    disabled: boolean | undefined;
+    dataDisabled: boolean | undefined;
+    className: string | undefined;
+    style: any;
+    styles: any;
+    classNames: any;
+    buttonRef: React.Ref<HTMLButtonElement> | undefined;
+    others: Record<string, any>;
+}
+export declare function MenuSelectableItem({ role, checked, indicator, onSelect, color, closeMenuOnClick, rightSection, children, disabled, dataDisabled, className, style, styles, classNames, buttonRef, others, }: MenuSelectableItemProps): import("react/jsx-runtime").JSX.Element;

package/lib/components/Menu/MenuSub/MenuSub.d.ts

@@ -1,3 +1,4 @@
+import { type SafePolygonOptions } from '@floating-ui/react';
 import { ExtendComponent, Factory } from '../../../core';
 import { FloatingAxesOffsets, FloatingPosition } from '../../../utils/Floating';
 import { __PopoverProps } from '../../Popover';
@@ -20,6 +21,8 @@ export interface MenuSubProps extends __PopoverProps {
     offset?: number | FloatingAxesOffsets;
     /** Props passed down to the `Transition` component that used to animate dropdown presence, use to configure duration and animation type @default { duration: 0 } */
     transitionProps?: TransitionOverride;
+    /** Determines whether submenu stays open while the cursor moves toward its dropdown. Pass an object to configure safe polygon behavior. @default true */
+    safeAreaPolygon?: boolean | SafePolygonOptions;
 }
 export declare function MenuSub(_props: MenuSubProps): import("react/jsx-runtime").JSX.Element;
 export declare namespace MenuSub {

package/lib/components/Menu/MenuSubItem/MenuSubItem.d.ts

@@ -1,5 +1,5 @@
 import { BoxProps, CompoundStylesApiProps, MantineColor, PolymorphicFactory } from '../../../core';
-export type MenuSubItemStylesNames = 'item' | 'itemLabel' | 'itemSection';
+export type MenuSubItemStylesNames = 'item' | 'itemLabel' | 'itemSection' | 'itemIndicator';
 export interface MenuSubItemProps extends BoxProps, CompoundStylesApiProps<MenuSubItemFactory> {
     'data-disabled'?: boolean;
     /** Item label */

package/lib/components/Menu/index.d.ts

@@ -1,9 +1,15 @@
 import type { MenuFactory, MenuProps, MenuStylesNames } from './Menu';
 import type { MenuContextValue } from './Menu.context';
+import type { MenuCheckboxGroupProps } from './MenuCheckboxGroup/MenuCheckboxGroup';
+import type { MenuCheckboxItemProps } from './MenuCheckboxItem/MenuCheckboxItem';
+import type { MenuContextMenuProps } from './MenuContextMenu/MenuContextMenu';
 import type { MenuDividerProps } from './MenuDivider/MenuDivider';
 import type { MenuDropdownProps } from './MenuDropdown/MenuDropdown';
 import type { MenuItemProps } from './MenuItem/MenuItem';
 import type { MenuLabelProps } from './MenuLabel/MenuLabel';
+import type { MenuRadioGroupProps } from './MenuRadioGroup/MenuRadioGroup';
+import type { MenuRadioItemProps } from './MenuRadioItem/MenuRadioItem';
+import type { MenuSearchProps } from './MenuSearch/MenuSearch';
 import type { MenuSubProps } from './MenuSub/MenuSub';
 import type { MenuSubDropdownProps } from './MenuSubDropdown/MenuSubDropdown';
 import type { MenuSubItemProps } from './MenuSubItem/MenuSubItem';
@@ -15,9 +21,15 @@ export { MenuItem } from './MenuItem/MenuItem';
 export { MenuLabel } from './MenuLabel/MenuLabel';
 export { MenuDropdown } from './MenuDropdown/MenuDropdown';
 export { MenuTarget } from './MenuTarget/MenuTarget';
+export { MenuSearch } from './MenuSearch/MenuSearch';
+export { MenuCheckboxItem } from './MenuCheckboxItem/MenuCheckboxItem';
+export { MenuCheckboxGroup } from './MenuCheckboxGroup/MenuCheckboxGroup';
+export { MenuRadioItem } from './MenuRadioItem/MenuRadioItem';
+export { MenuRadioGroup } from './MenuRadioGroup/MenuRadioGroup';
+export { MenuContextMenu } from './MenuContextMenu/MenuContextMenu';
 export { useMenuContext } from './Menu.context';
 export { MenuSub } from './MenuSub/MenuSub';
 export { MenuSubDropdown } from './MenuSubDropdown/MenuSubDropdown';
 export { MenuSubItem } from './MenuSubItem/MenuSubItem';
 export { MenuSubTarget } from './MenuSubTarget/MenuSubTarget';
-export type { MenuProps, MenuStylesNames, MenuFactory, MenuDividerProps, MenuItemProps, MenuLabelProps, MenuDropdownProps, MenuTargetProps, MenuContextValue, MenuSubProps, MenuSubDropdownProps, MenuSubItemProps, MenuSubTargetProps, };
+export type { MenuProps, MenuStylesNames, MenuFactory, MenuDividerProps, MenuItemProps, MenuLabelProps, MenuDropdownProps, MenuTargetProps, MenuSearchProps, MenuCheckboxItemProps, MenuCheckboxGroupProps, MenuRadioItemProps, MenuRadioGroupProps, MenuContextMenuProps, MenuContextValue, MenuSubProps, MenuSubDropdownProps, MenuSubItemProps, MenuSubTargetProps, };

package/lib/components/Menu/use-menu-type-ahead.d.ts

@@ -0,0 +1,7 @@
+interface UseMenuTypeAheadOptions {
+    enabled: boolean;
+    opened: boolean;
+    getDropdown: () => HTMLElement | null;
+}
+export declare function useMenuTypeAhead({ enabled, opened, getDropdown }: UseMenuTypeAheadOptions): (event: React.KeyboardEvent<HTMLElement>) => void;
+export {};

package/lib/components/Modal/ModalRoot.d.ts

@@ -25,12 +25,10 @@ export type ModalRootFactory = Factory<{
     ref: HTMLDivElement;
     stylesNames: ModalRootStylesNames;
     vars: ModalRootCssVariables;
-    compound: true;
 }>;
 export declare const ModalRoot: import("../..").MantineComponent<{
     props: ModalRootProps;
     ref: HTMLDivElement;
     stylesNames: ModalRootStylesNames;
     vars: ModalRootCssVariables;
-    compound: true;
 }>;

package/lib/components/OverflowList/OverflowList.d.ts

@@ -1,4 +1,3 @@
-import { Ref } from 'react';
 import { BoxProps, ElementProps, Factory, MantineSpacing, StylesApiProps } from '../../core';
 export type OverflowListStylesNames = 'root';
 export type OverflowListCssVariables = {
@@ -17,7 +16,13 @@ export interface OverflowListProps<T = any> extends BoxProps, StylesApiProps<Ove
     maxVisibleItems?: number;
     /** Key of `theme.spacing` or any valid CSS value for `gap`, numbers are converted to rem @default 'xs' */
     gap?: MantineSpacing;
-    ref?: Ref<HTMLDivElement>;
+    /** Direction from which items are collapsed when they overflow, `'end'` collapses last items, `'start'` collapses first items @default 'end' */
+    collapseFrom?: 'start' | 'end';
+    /** A function to resolve a unique key for each item. Used to detect when the contents of `data`
+     * change (for example when items are reordered while the length stays the same) so the
+     * visible/overflow split can be recomputed. Required to detect reordering when `data` contains
+     * objects; for primitive items (strings, numbers) the item value is used by default. */
+    getItemKey?: (item: T, index: number) => React.Key;
 }
 export type OverflowListFactory = Factory<{
     props: OverflowListProps<any>;

package/lib/components/Pagination/Pagination.context.d.ts

@@ -5,6 +5,7 @@ export interface PaginationContextValue {
     range: (number | 'dots')[];
     active: number;
     disabled: boolean | undefined;
+    layout?: 'default' | 'responsive';
     getItemProps?: (page: number) => Record<string, any>;
     onChange: (page: number) => void;
     onNext: () => void;

package/lib/components/Pagination/Pagination.d.ts

@@ -4,6 +4,7 @@ import { PaginationControl, type PaginationControlProps } from './PaginationCont
 import { PaginationDots, type PaginationDotsProps } from './PaginationDots/PaginationDots';
 import { PaginationFirst, PaginationLast, PaginationNext, PaginationPrevious, type PaginationEdgeProps } from './PaginationEdges/PaginationEdges';
 import { PaginationItems, type PaginationItemsProps } from './PaginationItems/PaginationItems';
+import { PaginationFormatLabel, PaginationLabel, type PaginationLabelProps } from './PaginationLabel/PaginationLabel';
 import { PaginationRoot, PaginationRootCssVariables, PaginationRootProps, PaginationRootStylesNames } from './PaginationRoot/PaginationRoot';
 export type PaginationStylesNames = PaginationRootStylesNames;
 export type PaginationCssVariables = PaginationRootCssVariables;
@@ -30,6 +31,8 @@ export interface PaginationProps extends PaginationRootProps {
     hideWithOnePage?: boolean;
     /** If set to `false`, page number buttons are hidden, only next/previous controls remain @default `true` */
     withPages?: boolean;
+    /** Function to format the label text displayed in responsive mode */
+    formatLabel?: PaginationFormatLabel;
 }
 export type PaginationFactory = Factory<{
     props: PaginationProps;
@@ -45,6 +48,7 @@ export type PaginationFactory = Factory<{
         Next: typeof PaginationNext;
         Previous: typeof PaginationPrevious;
         Items: typeof PaginationItems;
+        Label: typeof PaginationLabel;
     };
 }>;
 export declare const Pagination: import("../..").MantineComponent<{
@@ -61,6 +65,7 @@ export declare const Pagination: import("../..").MantineComponent<{
         Next: typeof PaginationNext;
         Previous: typeof PaginationPrevious;
         Items: typeof PaginationItems;
+        Label: typeof PaginationLabel;
     };
 }>;
 export declare namespace Pagination {
@@ -83,4 +88,7 @@ export declare namespace Pagination {
     namespace Items {
         type Props = PaginationItemsProps;
     }
+    namespace Label {
+        type Props = PaginationLabelProps;
+    }
 }

package/lib/components/Pagination/PaginationLabel/PaginationLabel.d.ts

@@ -0,0 +1,22 @@
+import { BoxProps, CompoundStylesApiProps, ElementProps, Factory } from '../../../core';
+export type PaginationFormatLabel = (input: {
+    page: number;
+    totalPages: number;
+}) => string;
+export type PaginationLabelStylesNames = 'label';
+export interface PaginationLabelProps extends BoxProps, CompoundStylesApiProps<PaginationLabelFactory>, ElementProps<'div'> {
+    /** Function to format the label text */
+    formatLabel?: PaginationFormatLabel;
+}
+export type PaginationLabelFactory = Factory<{
+    props: PaginationLabelProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationLabelStylesNames;
+    compound: true;
+}>;
+export declare const PaginationLabel: import("../../..").MantineComponent<{
+    props: PaginationLabelProps;
+    ref: HTMLDivElement;
+    stylesNames: PaginationLabelStylesNames;
+    compound: true;
+}>;

package/lib/components/Pagination/PaginationRoot/PaginationRoot.d.ts

@@ -1,5 +1,5 @@
 import { BoxProps, ElementProps, Factory, MantineColor, MantineRadius, MantineSize, StylesApiProps } from '../../../core';
-export type PaginationRootStylesNames = 'root' | 'control' | 'dots';
+export type PaginationRootStylesNames = 'root' | 'control' | 'dots' | 'items' | 'label';
 export type PaginationRootCssVariables = {
     root: '--pagination-control-size' | '--pagination-control-radius' | '--pagination-control-fz' | '--pagination-active-bg' | '--pagination-active-color';
 };
@@ -38,6 +38,8 @@ export interface PaginationRootProps extends BoxProps, StylesApiProps<Pagination
     autoContrast?: boolean;
     /** Starting page number, defaults to 1 */
     startValue?: number;
+    /** Determines how the pagination is displayed, `'responsive'` uses CSS container queries to switch between pages and a compact label @default 'default' */
+    layout?: 'default' | 'responsive';
 }
 export type PaginationRootFactory = Factory<{
     props: PaginationRootProps;

package/lib/components/Pagination/index.d.ts

@@ -4,12 +4,14 @@ import type { PaginationControlProps } from './PaginationControl/PaginationContr
 import type { PaginationDotsProps } from './PaginationDots/PaginationDots';
 import type { PaginationEdgeProps } from './PaginationEdges/PaginationEdges';
 import type { PaginationItemsProps } from './PaginationItems/PaginationItems';
+import type { PaginationFormatLabel, PaginationLabelProps } from './PaginationLabel/PaginationLabel';
 import type { PaginationRootProps } from './PaginationRoot/PaginationRoot';
 export { Pagination } from './Pagination';
 export { PaginationControl } from './PaginationControl/PaginationControl';
 export { PaginationDots } from './PaginationDots/PaginationDots';
 export { PaginationFirst, PaginationLast, PaginationNext, PaginationPrevious, } from './PaginationEdges/PaginationEdges';
 export { PaginationItems } from './PaginationItems/PaginationItems';
+export { PaginationLabel } from './PaginationLabel/PaginationLabel';
 export { PaginationRoot } from './PaginationRoot/PaginationRoot';
 export { usePaginationContext } from './Pagination.context';
-export type { PaginationProps, PaginationStylesNames, PaginationCssVariables, PaginationFactory, PaginationRootProps, PaginationControlProps, PaginationDotsProps, PaginationEdgeProps, PaginationItemsProps, PaginationContextValue, };
+export type { PaginationProps, PaginationStylesNames, PaginationCssVariables, PaginationFactory, PaginationRootProps, PaginationControlProps, PaginationDotsProps, PaginationEdgeProps, PaginationItemsProps, PaginationLabelProps, PaginationFormatLabel, PaginationContextValue, };

package/lib/components/Popover/Popover.d.ts

@@ -5,6 +5,7 @@ import { BasePortalProps } from '../Portal';
 import { TransitionOverride } from '../Transition';
 import { PopoverContextValue } from './Popover.context';
 import { PopoverMiddlewares, PopoverWidth } from './Popover.types';
+import { PopoverContextMenu, PopoverContextMenuProps } from './PopoverContextMenu/PopoverContextMenu';
 import { PopoverDropdownProps } from './PopoverDropdown/PopoverDropdown';
 import { PopoverTargetProps } from './PopoverTarget/PopoverTarget';
 export type PopoverStylesNames = 'dropdown' | 'arrow' | 'overlay';
@@ -68,7 +69,7 @@ export interface __PopoverProps {
     floatingStrategy?: FloatingStrategy;
     /** If set, the dropdown is hidden when the element is hidden with styles or not visible on the screen @default true */
     hideDetached?: boolean;
-    /** Prevents popover from flipping/shifting when it the dropdown is visible */
+    /** If `true`, the dropdown picks its side on open (flip runs once, preferring the `position` prop) and then never changes side — scrolling, resizing, and content size changes will not flip the dropdown. The side is recalculated fresh on the next open. Does not affect the `shift` middleware. Set to `false` to keep flip active and allow the dropdown to re-flip on every change. @default true */
     preventPositionChangeWhenVisible?: boolean;
 }
 export interface PopoverProps extends __PopoverProps, StylesApiProps<PopoverFactory> {
@@ -112,6 +113,7 @@ export declare namespace Popover {
         stylesNames: PopoverStylesNames;
         compound: true;
     }>;
+    var ContextMenu: typeof PopoverContextMenu;
     var varsResolver: import("../..").VarsResolver<{
         props: PopoverProps;
         stylesNames: PopoverStylesNames;
@@ -148,4 +150,7 @@ export declare namespace Popover {
     namespace Dropdown {
         type Props = PopoverDropdownProps;
     }
+    namespace ContextMenu {
+        type Props = PopoverContextMenuProps;
+    }
 }

package/lib/components/Popover/PopoverContextMenu/PopoverContextMenu.d.ts

@@ -0,0 +1,10 @@
+export interface PopoverContextMenuProps {
+    /** Element that opens the popover when right-clicked. Dropdown is positioned at the cursor. The trigger element must not call `event.preventDefault()` in its own `onContextMenu` handler, otherwise the native context menu is not suppressed. */
+    children: React.ReactNode;
+    /** If set, the right-click trigger is disabled and the browser's default context menu is shown */
+    disabled?: boolean;
+}
+export declare function PopoverContextMenu(props: PopoverContextMenuProps): import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>>;
+export declare namespace PopoverContextMenu {
+    var displayName: string;
+}

package/lib/components/Popover/index.d.ts

@@ -1,10 +1,12 @@
 import type { __PopoverProps, PopoverFactory, PopoverProps, PopoverStylesNames } from './Popover';
 import type { PopoverContextValue } from './Popover.context';
 import type { PopoverWidth } from './Popover.types';
+import type { PopoverContextMenuProps } from './PopoverContextMenu/PopoverContextMenu';
 import type { PopoverDropdownProps } from './PopoverDropdown/PopoverDropdown';
 import type { PopoverTargetProps } from './PopoverTarget/PopoverTarget';
 export { Popover } from './Popover';
 export { PopoverDropdown } from './PopoverDropdown/PopoverDropdown';
 export { PopoverTarget } from './PopoverTarget/PopoverTarget';
+export { PopoverContextMenu } from './PopoverContextMenu/PopoverContextMenu';
 export { usePopoverContext } from './Popover.context';
-export type { PopoverProps, __PopoverProps, PopoverFactory, PopoverStylesNames, PopoverTargetProps, PopoverDropdownProps, PopoverWidth, PopoverContextValue, };
+export type { PopoverProps, __PopoverProps, PopoverFactory, PopoverStylesNames, PopoverTargetProps, PopoverDropdownProps, PopoverContextMenuProps, PopoverWidth, PopoverContextValue, };

package/lib/components/Popover/use-popover.d.ts

@@ -15,9 +15,6 @@ interface UsePopoverOptions {
     arrowRef: React.RefObject<HTMLDivElement | null>;
     arrowOffset: number;
     strategy?: FloatingStrategy;
-    dropdownVisible: boolean;
-    setDropdownVisible: (visible: boolean) => void;
-    positionRef: React.RefObject<FloatingPosition>;
     disabled: boolean | undefined;
     preventPositionChangeWhenVisible: boolean | undefined;
     keepMounted: boolean | undefined;
@@ -65,5 +62,6 @@ export declare function usePopover(options: UsePopoverOptions): {
     opened: boolean;
     onClose: () => void;
     onToggle: () => void;
+    resetLockedPlacement: () => void;
 };
 export {};

package/lib/components/Radio/RadioIndicator/RadioIndicator.d.ts

@@ -9,7 +9,7 @@ export interface RadioIndicatorProps extends BoxProps, StylesApiProps<RadioIndic
     /** Key of theme.colors or any valid CSS color to set indicator background color in checked state @default theme.primaryColor */
     color?: MantineColor;
     /** Controls size of the component @default 'sm' */
-    size?: MantineSize | (string & {});
+    size?: MantineSize | (string & {}) | number;
     /** Key of `theme.radius` or any valid CSS value to set `border-radius` @default theme.defaultRadius */
     radius?: MantineRadius;
     /** Key of theme.colors or any valid CSS color to set icon color. When not set, icon color is determined automatically based on theme.autoContrast setting */

package/lib/components/Splitter/GripIcon.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+export declare function GripVerticalIcon(props: React.ComponentPropsWithoutRef<'svg'>): import("react/jsx-runtime").JSX.Element;
+export declare function GripHorizontalIcon(props: React.ComponentPropsWithoutRef<'svg'>): import("react/jsx-runtime").JSX.Element;

package/lib/components/Splitter/Splitter.context.d.ts

@@ -0,0 +1,9 @@
+import { GetStylesApi } from '../../core';
+import type { SplitterFactory } from './Splitter';
+export interface SplitterContextValue {
+    getStyles: GetStylesApi<SplitterFactory>;
+    sizes: number[];
+    collapsed: boolean[];
+    orientation: 'horizontal' | 'vertical';
+}
+export declare const SplitterProvider: import("react").Context<SplitterContextValue | null>, useSplitterContext: () => SplitterContextValue;

package/lib/components/Splitter/Splitter.d.ts

@@ -0,0 +1,57 @@
+import { UseSplitterRedistributeFn, UseSplitterReturnValue } from '@mantine/hooks';
+import { BoxProps, ElementProps, Factory, MantineColor, StylesApiProps } from '../../core';
+import { SplitterPane, SplitterPaneStylesNames } from './SplitterPane/SplitterPane';
+export type SplitterStylesNames = 'root' | 'handle' | 'thumb' | SplitterPaneStylesNames;
+export type SplitterCssVariables = {
+    root: '--splitter-line-size' | '--splitter-handle-color';
+};
+export interface SplitterProps extends BoxProps, StylesApiProps<SplitterFactory>, ElementProps<'div'> {
+    /** Layout direction @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical';
+    /** Controlled sizes (percentages summing to 100) */
+    sizes?: number[];
+    /** Called during resize with updated sizes */
+    onSizeChange?: (sizes: number[]) => void;
+    /** Called when drag starts */
+    onResizeStart?: (handleIndex: number) => void;
+    /** Called when drag ends */
+    onResizeEnd?: (handleIndex: number, sizes: number[]) => void;
+    /** Called when a panel collapses or expands */
+    onCollapseChange?: (panelIndex: number, collapsed: boolean) => void;
+    /** How to redistribute space when immediate neighbor is at its min/max */
+    redistribute?: 'nearest' | 'equal' | UseSplitterRedistributeFn;
+    /** Keyboard step size in percentage @default 1 */
+    step?: number;
+    /** Shift+arrow step size in percentage @default 10 */
+    shiftStep?: number;
+    /** CSS value for separator line thickness between panes @default 2 */
+    lineSize?: number | string;
+    /** Key of `theme.colors` or any valid CSS color for the separator line */
+    handleColor?: MantineColor;
+    /** Custom icon displayed in the handle thumb, by default uses grip icon based on orientation */
+    handleIcon?: React.ReactNode;
+    /** Determines whether the thumb with grip icon is displayed on the handle @default true */
+    withHandle?: boolean;
+    /** Ref to imperative splitter API (sizes, collapse, expand, etc.) */
+    splitterRef?: React.RefObject<UseSplitterReturnValue | null>;
+    /** Splitter panes */
+    children?: React.ReactNode;
+}
+export type SplitterFactory = Factory<{
+    props: SplitterProps;
+    ref: HTMLDivElement;
+    stylesNames: SplitterStylesNames;
+    vars: SplitterCssVariables;
+    staticComponents: {
+        Pane: typeof SplitterPane;
+    };
+}>;
+export declare const Splitter: import("../..").MantineComponent<{
+    props: SplitterProps;
+    ref: HTMLDivElement;
+    stylesNames: SplitterStylesNames;
+    vars: SplitterCssVariables;
+    staticComponents: {
+        Pane: typeof SplitterPane;
+    };
+}>;

package/lib/components/Splitter/SplitterPane/SplitterPane.d.ts

@@ -0,0 +1,30 @@
+import { BoxProps, CompoundStylesApiProps, ElementProps, Factory } from '../../../core';
+export type SplitterPaneStylesNames = 'pane';
+export interface SplitterPaneProps extends BoxProps, CompoundStylesApiProps<SplitterPaneFactory>, ElementProps<'div'> {
+    /** Initial size as percentage (0-100). All panes must sum to 100. */
+    defaultSize: number;
+    /** Minimum size percentage @default 0 */
+    min?: number;
+    /** Maximum size percentage @default 100 */
+    max?: number;
+    /** Whether this pane can be collapsed @default false */
+    collapsible?: boolean;
+    /** Size below which the pane snaps to collapsed (percentage), defaults to `min` */
+    collapseThreshold?: number;
+    /** Pane content */
+    children?: React.ReactNode;
+    /** @internal Index set by parent */
+    __index?: number;
+}
+export type SplitterPaneFactory = Factory<{
+    props: SplitterPaneProps;
+    ref: HTMLDivElement;
+    stylesNames: SplitterPaneStylesNames;
+    compound: true;
+}>;
+export declare const SplitterPane: import("../../..").MantineComponent<{
+    props: SplitterPaneProps;
+    ref: HTMLDivElement;
+    stylesNames: SplitterPaneStylesNames;
+    compound: true;
+}>;

package/lib/components/Splitter/index.d.ts

@@ -0,0 +1,18 @@
+import type { SplitterCssVariables, SplitterFactory, SplitterProps, SplitterStylesNames } from './Splitter';
+import type { SplitterContextValue } from './Splitter.context';
+import type { SplitterPaneProps, SplitterPaneStylesNames } from './SplitterPane/SplitterPane';
+export { Splitter } from './Splitter';
+export { SplitterPane } from './SplitterPane/SplitterPane';
+export { useSplitterContext } from './Splitter.context';
+export type { SplitterProps, SplitterStylesNames, SplitterCssVariables, SplitterFactory, SplitterPaneProps, SplitterPaneStylesNames, SplitterContextValue, };
+export declare namespace Splitter {
+    type Props = SplitterProps;
+    type StylesNames = SplitterStylesNames;
+    type CssVariables = SplitterCssVariables;
+    type Factory = SplitterFactory;
+    type ContextValue = SplitterContextValue;
+    namespace Pane {
+        type Props = SplitterPaneProps;
+        type StylesNames = SplitterPaneStylesNames;
+    }
+}

package/lib/components/Text/Text.d.ts

@@ -3,7 +3,7 @@ type TextTruncate = 'end' | 'start' | boolean;
 export type TextStylesNames = 'root';
 export type TextVariant = 'text' | 'gradient';
 export type TextCssVariables = {
-    root: '--text-gradient' | '--text-line-clamp' | '--text-fz' | '--text-lh';
+    root: '--text-gradient' | '--text-line-clamp' | '--text-fz' | '--text-lh' | '--text-text-wrap';
 };
 export interface TextProps extends BoxProps, StylesApiProps<TextFactory> {
     __staticSelector?: string;
@@ -21,6 +21,8 @@ export interface TextProps extends BoxProps, StylesApiProps<TextFactory> {
     gradient?: MantineGradient;
     /** Shorthand for `component="span"` */
     span?: boolean;
+    /** Controls `text-wrap` CSS property */
+    textWrap?: 'wrap' | 'nowrap' | 'balance' | 'pretty' | 'stable';
 }
 export type TextFactory = PolymorphicFactory<{
     props: TextProps;

package/lib/components/Textarea/Textarea.d.ts

@@ -10,6 +10,10 @@ export interface TextareaProps extends BoxProps, __BaseInputProps, StylesApiProp
     minRows?: number;
     /** Controls `resize` CSS property @default 'none' */
     resize?: React.CSSProperties['resize'];
+    /** Content rendered at the bottom of the input, inside the border */
+    bottomSection?: React.ReactNode;
+    /** Props passed down to the `bottomSection` element */
+    bottomSectionProps?: React.ComponentProps<'div'>;
 }
 export type TextareaFactory = Factory<{
     props: TextareaProps;

package/lib/components/Tree/FlatTreeNode.d.ts

@@ -1,3 +1,4 @@
+import type { FlatTreeLineState } from './flatten-tree-data/flatten-tree-data';
 import type { RenderNode, TreeNodeData } from './Tree';
 import type { TreeController } from './use-tree';
 export interface FlatTreeNodeProps {
@@ -27,5 +28,8 @@ export interface FlatTreeNodeProps {
     style?: React.CSSProperties;
     /** Tab index for the node */
     tabIndex?: number;
+    /** Line state per ancestor + own level, computed by `flattenTreeData`.
+     * When provided and the tree root has `data-with-lines`, connector lines are rendered. */
+    linesPath?: FlatTreeLineState[];
 }
-export declare const FlatTreeNode: import("react").MemoExoticComponent<({ node, level, parent, hasChildren, expanded, tree, expandOnClick, selectOnClick, expandOnSpace, checkOnSpace, renderNode, style, tabIndex, }: FlatTreeNodeProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const FlatTreeNode: import("react").MemoExoticComponent<({ node, level, parent, hasChildren, expanded, tree, expandOnClick, selectOnClick, expandOnSpace, checkOnSpace, renderNode, style, tabIndex, linesPath, }: FlatTreeNodeProps) => import("react/jsx-runtime").JSX.Element>;

package/lib/components/Tree/Tree.d.ts

@@ -18,6 +18,8 @@ export interface RenderTreeNodePayload {
     hasChildren: boolean;
     /** `true` if the node is selected */
     selected: boolean;
+    /** `true` if the node is at the top-most level of the tree (level 1) */
+    isRoot: boolean;
     /** `true` if the node's children are currently being loaded */
     isLoading: boolean;
     /** Error from the last failed load attempt, or `null` */

package/lib/components/Tree/flatten-tree-data/flatten-tree-data.d.ts

@@ -1,5 +1,6 @@
 import type { TreeNodeData } from '../Tree';
 import type { TreeExpandedState } from '../use-tree';
+export type FlatTreeLineState = 'continuing' | 'closing' | 'none';
 export interface FlattenedTreeNodeData {
     /** Node data from tree data */
     node: TreeNodeData;
@@ -11,5 +12,14 @@ export interface FlattenedTreeNodeData {
     hasChildren: boolean;
     /** Whether the node is expanded */
     expanded: boolean;
+    /** For each level from 2 to this node's `level`, indicates whether a connector
+     * line should be drawn at that column for this row:
+     * - `'continuing'`: full vertical line passes through this row
+     * - `'closing'`: line ends at this row (truncated to the connector level)
+     * - `'none'`: no line at this column for this row
+     *
+     * Index 0 corresponds to level 2, index 1 to level 3, etc.
+     * Empty for level-1 (root) nodes. */
+    linesPath: FlatTreeLineState[];
 }
 export declare function flattenTreeData(data: TreeNodeData[], expandedState: TreeExpandedState): FlattenedTreeNodeData[];

package/lib/components/Tree/index.d.ts

@@ -11,6 +11,6 @@ export { FlatTreeNode } from './FlatTreeNode';
 export type { TreeProps, TreeStylesNames, TreeFactory, TreeCssVariables, TreeNodeData, RenderTreeNodePayload, UseTreeInput, UseTreeReturnType, CheckedNodeStatus, };
 export type { TreeNodeFilter } from './filter-tree-data/filter-tree-data';
 export type { TreeDragDropPosition, TreeDragDropPayload } from './move-tree-node/move-tree-node';
-export type { FlattenedTreeNodeData } from './flatten-tree-data/flatten-tree-data';
+export type { FlattenedTreeNodeData, FlatTreeLineState, } from './flatten-tree-data/flatten-tree-data';
 export type { FlatTreeNodeProps } from './FlatTreeNode';
 export type { TreeAllowDrop, TreeDragHandleProps } from './use-tree-node-drag-drop';

package/lib/components/Tree/use-tree-node-drag-drop.d.ts

@@ -4,6 +4,7 @@ export type TreeAllowDrop = (payload: TreeDragDropPayload) => boolean;
 interface UseTreeNodeDragDropInput {
     nodeValue: string;
     hasChildren: boolean;
+    isExpanded: boolean;
     data: TreeNodeData[];
     onDragDrop: ((payload: TreeDragDropPayload) => void) | undefined;
     dragStateRef: React.RefObject<TreeDragState>;
@@ -13,7 +14,7 @@ interface UseTreeNodeDragDropInput {
 export interface TreeDragHandleProps {
     onMouseDown: (event: React.MouseEvent) => void;
 }
-export declare function useTreeNodeDragDrop({ nodeValue, hasChildren, data, onDragDrop, dragStateRef, allowDrop, withDragHandle, }: UseTreeNodeDragDropInput): {
+export declare function useTreeNodeDragDrop({ nodeValue, hasChildren, isExpanded, data, onDragDrop, dragStateRef, allowDrop, withDragHandle, }: UseTreeNodeDragDropInput): {
     readonly elementProps: {};
     readonly dragHandleProps: undefined;
 } | {

package/lib/components/index.d.ts

@@ -89,6 +89,7 @@ export * from './SimpleGrid';
 export * from './Skeleton';
 export * from './Slider';
 export * from './Space';
+export * from './Splitter';
 export * from './Spoiler';
 export * from './Stack';
 export * from './Stepper';

package/lib/utils/Floating/FloatingArrow/get-arrow-position-styles.d.ts

@@ -9,3 +9,7 @@ export declare function getArrowPositionStyles({ position, arrowSize, arrowOffse
     arrowY: number | undefined;
     dir: 'rtl' | 'ltr';
 }): {};
+export declare function getArrowMergeDropdownStyles({ position, dir, }: {
+    position: FloatingPosition;
+    dir: 'rtl' | 'ltr';
+}): React.CSSProperties | undefined;

package/lib/utils/Floating/create-context-menu-handlers.d.ts

@@ -0,0 +1,18 @@
+interface CreateContextMenuHandlersOptions {
+    /** Props of the child element that opens the dropdown */
+    childProps: Record<string, any>;
+    /** If set, right-click trigger is disabled and the browser's default context menu is shown */
+    disabled: boolean | undefined;
+    /** Current opened state, used to set `data-expanded` on the child */
+    opened: boolean;
+    /** Sets the floating reference to a virtual element positioned at the cursor */
+    setReference: (node: object) => void;
+    /** Called to open the dropdown after the reference has been set */
+    open: () => void;
+}
+export declare function createContextMenuHandlers({ childProps, disabled, opened, setReference, open, }: CreateContextMenuHandlersOptions): {
+    onContextMenu: (event?: any) => void;
+    onMouseDown: (event?: any) => void;
+    'data-expanded': boolean | undefined;
+};
+export {};

package/lib/utils/Floating/index.d.ts

@@ -1,4 +1,5 @@
 export { FloatingArrow } from './FloatingArrow/FloatingArrow';
+export { getArrowMergeDropdownStyles } from './FloatingArrow/get-arrow-position-styles';
 export { getFloatingPosition } from './get-floating-position/get-floating-position';
 export { useDelayedHover } from './use-delayed-hover';
 export type { ArrowPosition, FloatingAxesOffsets, FloatingPlacement, FloatingPosition, FloatingSide, FloatingStrategy, } from './types';

package/lib/utils/Floating/types.d.ts

@@ -1,7 +1,7 @@
 export type FloatingPlacement = 'end' | 'start';
 export type FloatingSide = 'top' | 'right' | 'bottom' | 'left';
 export type FloatingPosition = FloatingSide | `${FloatingSide}-${FloatingPlacement}`;
-export type ArrowPosition = 'center' | 'side';
+export type ArrowPosition = 'center' | 'side' | 'merge';
 export type FloatingStrategy = 'absolute' | 'fixed';
 export interface FloatingAxesOffsets {
     mainAxis?: number;