@mantine/core 7.0.0-alpha.14 → 7.0.0-alpha.15

package/esm/components/Tabs/Tabs.js

@@ -5,10 +5,10 @@ import { TabsList } from './TabsList/TabsList.js';
 import { TabsPanel } from './TabsPanel/TabsPanel.js';
 import { TabsTab } from './TabsTab/TabsTab.js';
 import classes from './Tabs.module.css.js';
-import { getSafeId } from '../../core/utils/get-safe-id/get-safe-id.js';
 import { factory } from '../../core/factory/factory.js';
 import { useProps } from '../../core/MantineProvider/use-props/use-props.js';
 import { useStyles } from '../../core/styles-api/use-styles/use-styles.js';
+import { getSafeId } from '../../core/utils/get-safe-id/get-safe-id.js';
 import { Box } from '../../core/Box/Box.js';
 import { createVarsResolver } from '../../core/styles-api/create-vars-resolver/create-vars-resolver.js';
 import { getRadius } from '../../core/utils/get-size/get-size.js';

package/esm/components/Tabs/TabsTab/TabsTab.js

@@ -2,12 +2,12 @@ import React from 'react';
 import { useTabsContext } from '../Tabs.context.js';
 import classes from '../Tabs.module.css.js';
 import { UnstyledButton } from '../../UnstyledButton/UnstyledButton.js';
-import { createScopedKeydownHandler } from '../../../core/utils/create-scoped-keydown-handler/create-scoped-keydown-handler.js';
 import { factory } from '../../../core/factory/factory.js';
 import { useProps } from '../../../core/MantineProvider/use-props/use-props.js';
 import { useMantineTheme } from '../../../core/MantineProvider/MantineThemeProvider/MantineThemeProvider.js';
 import { useDirection } from '../../../core/DirectionProvider/DirectionProvider.js';
 import { getThemeColor } from '../../../core/MantineProvider/color-functions/get-theme-color/get-theme-color.js';
+import { createScopedKeydownHandler } from '../../../core/utils/create-scoped-keydown-handler/create-scoped-keydown-handler.js';
 
 var __defProp = Object.defineProperty;
 var __defProps = Object.defineProperties;

package/esm/index.css

@@ -547,6 +547,240 @@ body {
   -webkit-tap-highlight-color: transparent;
 }
 
+.mantine-27MenJe {
+  border: 0;
+  clip: rect(0 0 0 0);
+  height: 1px;
+  width: 1px;
+  margin: -1px;
+  overflow: hidden;
+  padding: 0;
+  position: absolute;
+  white-space: nowrap;
+}
+
+.mantine-BsW-DHJ {
+  word-break: break-word;
+}
+
+.mantine-crxTXa8 {
+  padding: var(--mantine-spacing-md);
+  padding-top: calc(var(--mantine-spacing-xs) / 2);
+}
+
+.mantine-Pl85DwB {
+  margin: 0;
+  padding: 0;
+}
+
+.mantine-GdbdUfZ {
+  width: 100%;
+  display: flex;
+  align-items: center;
+  flex-direction: var(--_control-flex-direction, row-reverse);
+  padding-right: var(--_control-padding-right, var(--mantine-spacing-md));
+  padding-left: var(--_control-padding-left, var(--mantine-spacing-md));
+  text-align: left;
+  color: var(--_control-color);
+  opacity: var(--_control-opacity, 1);
+  cursor: var(--_control-cursor, pointer);
+  background-color: var(--_control-background-color, transparent);
+}
+
+.mantine-GdbdUfZ[data-chevron-position='left'] {
+    --_control-flex-direction: row;
+    --_control-padding-left: 0;
+  }
+
+[dir="rtl"] .mantine-GdbdUfZ[data-chevron-position='left'] {
+      --_control-padding-left: var(--mantine-spacing-md);
+    }
+
+[data-mantine-color-scheme='light'] .mantine-GdbdUfZ {
+    --_control-color: var(--mantine-color-black);
+}
+
+[data-mantine-color-scheme='dark'] .mantine-GdbdUfZ {
+    --_control-color: var(--mantine-color-dark-0);
+}
+
+.mantine-GdbdUfZ:disabled,
+  .mantine-GdbdUfZ[data-disabled] {
+    --_control-opacity: 0.4;
+    --_control-cursor: not-allowed;
+  }
+
+@media (hover: hover) {
+      [data-mantine-color-scheme='light'] .mantine-NYL8sTC:not(:disabled, [data-disabled]):hover, [data-mantine-color-scheme='light'] .mantine-2ff9CY2:not(:disabled, [data-disabled]):hover {
+        --_control-background-color: var(--mantine-color-gray-0);
+  }
+
+      [data-mantine-color-scheme='dark'] .mantine-NYL8sTC:not(:disabled, [data-disabled]):hover, [data-mantine-color-scheme='dark'] .mantine-2ff9CY2:not(:disabled, [data-disabled]):hover {
+        --_control-background-color: var(--mantine-color-dark-6);
+  }
+}
+
+@media (hover: none) {
+      [data-mantine-color-scheme='light'] .mantine-NYL8sTC:not(:disabled, [data-disabled]):active, [data-mantine-color-scheme='light'] .mantine-2ff9CY2:not(:disabled, [data-disabled]):active {
+        --_control-background-color: var(--mantine-color-gray-0);
+  }
+
+      [data-mantine-color-scheme='dark'] .mantine-NYL8sTC:not(:disabled, [data-disabled]):active, [data-mantine-color-scheme='dark'] .mantine-2ff9CY2:not(:disabled, [data-disabled]):active {
+        --_control-background-color: var(--mantine-color-dark-6);
+  }
+}
+
+.mantine-wi6tb4S {
+  color: inherit;
+  font-weight: 400;
+  flex: 1;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  padding-top: var(--mantine-spacing-sm);
+  padding-bottom: var(--mantine-spacing-sm);
+}
+
+.mantine-cn4jUEr {
+  display: flex;
+  align-items: center;
+  justify-content: flex-start;
+  transition: transform var(--accordion-transition-duration) ease;
+  margin-right: var(--_chevron-margin-right);
+  margin-left: var(--_chevron-margin-left);
+  width: var(--accordion-chevron-size);
+  min-width: var(--accordion-chevron-size);
+  transform: var(--_chevron-transform, rotate(0deg));
+}
+
+.mantine-cn4jUEr[data-rotate] {
+    --_chevron-transform: rotate(180deg);
+  }
+
+.mantine-cn4jUEr[data-position='left'] {
+    --_chevron-margin-right: var(--mantine-spacing-md);
+    --_chevron-margin-left: var(--mantine-spacing-md);
+  }
+
+.mantine-cn4jUEr[data-position='right'] {
+    --_chevron-margin-left: 0;
+  }
+
+[dir="rtl"] .mantine-cn4jUEr[data-position='left'] {
+      --_chevron-margin-right: 0;
+      --_chevron-margin-left: var(--mantine-spacing-md);
+    }
+
+[dir="rtl"] .mantine-cn4jUEr[data-position='right'] {
+      --_chevron-margin-right: var(--mantine-spacing-md);
+      --_chevron-margin-left: 0;
+    }
+
+.mantine-UIeeOMI {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  margin-right: var(--_icon-margin-right, var(--mantine-spacing-sm));
+  margin-left: var(--_icon-margin-left, 0);
+}
+
+.mantine-UIeeOMI[data-chevron-position='left'] {
+    --_icon-margin-right: 0;
+    --_icon-margin-left: var(--mantine-spacing-lg);
+  }
+
+[dir="rtl"] .mantine-UIeeOMI[data-chevron-position='left'] {
+      --_icon-margin-right: var(--mantine-spacing-lg);
+      --_icon-margin-left: 0;
+    }
+
+[dir="rtl"] .mantine-UIeeOMI[data-chevron-position='right'] {
+      --_icon-margin-right: 0;
+      --_icon-margin-left: var(--mantine-spacing-sm);
+    }
+
+.mantine-O9fHDxs {
+  background-color: var(--_item-bg);
+}
+
+[data-mantine-color-scheme='light'] .mantine-O9fHDxs {
+    --_item-border-color: var(--mantine-color-gray-3);
+    --_item-filled-color: var(--mantine-color-gray-0);
+}
+
+[data-mantine-color-scheme='dark'] .mantine-O9fHDxs {
+    --_item-border-color: var(--mantine-color-dark-4);
+    --_item-filled-color: var(--mantine-color-dark-6);
+}
+
+.mantine-NikJAJO {
+  border-bottom: calc(0.0625rem * var(--mantine-scale)) solid var(--_item-border-color);
+}
+
+.mantine-J3GNfAk {
+  border: calc(0.0625rem * var(--mantine-scale)) solid var(--_item-border-color);
+  transition: background-color 150ms ease;
+}
+
+.mantine-J3GNfAk[data-active] {
+    --_item-bg: var(--_item-filled-color);
+  }
+
+.mantine-J3GNfAk:first-of-type {
+    border-top-left-radius: var(--accordion-radius);
+    border-top-right-radius: var(--accordion-radius);
+  }
+
+.mantine-J3GNfAk:first-of-type > [data-accordion-control] {
+      border-top-left-radius: var(--accordion-radius);
+      border-top-right-radius: var(--accordion-radius);
+    }
+
+.mantine-J3GNfAk:last-of-type {
+    border-bottom-left-radius: var(--accordion-radius);
+    border-bottom-right-radius: var(--accordion-radius);
+  }
+
+.mantine-J3GNfAk:last-of-type > [data-accordion-control] {
+      border-bottom-left-radius: var(--accordion-radius);
+      border-bottom-right-radius: var(--accordion-radius);
+    }
+
+.mantine-J3GNfAk + .mantine-J3GNfAk {
+    border-top: 0;
+  }
+
+.mantine-sjWzs17 {
+  border-radius: var(--accordion-radius);
+}
+
+.mantine-sjWzs17[data-active] {
+    --_item-bg: var(--_item-filled-color);
+  }
+
+.mantine-C9LZ3zN {
+  --_item-bg: var(--_item-filled-color);
+
+  border-radius: var(--accordion-radius);
+  border: calc(0.0625rem * var(--mantine-scale)) solid var(--__item-border-color, transparent);
+  transition: background-color 150ms ease;
+}
+
+.mantine-C9LZ3zN[data-active] {
+    --__item-border-color: var(--_item-border-color);
+  }
+
+[data-mantine-color-scheme='light'] .mantine-C9LZ3zN[data-active] {
+      --_item-bg: var(--mantine-color-white);
+}
+
+[data-mantine-color-scheme='dark'] .mantine-C9LZ3zN[data-active] {
+      --_item-bg: var(--mantine-color-dark-7);
+}
+
+.mantine-C9LZ3zN + .mantine-C9LZ3zN {
+    margin-top: var(--mantine-spacing-md);
+  }
+
 @keyframes mantine-CbbKYq7 {
   0% {
     transform: scale(0.6);
@@ -2370,6 +2604,35 @@ body {
   color: var(--mantine-color-dimmed);
 }
 
+.mantine-raltP2G,
+.mantine-dRrkbFg {
+  font-size: var(--combobox-option-fz);
+  border: 0 solid var(--_footer-border-color);
+  margin-left: calc(var(--combobox-padding) * -1);
+  margin-right: calc(var(--combobox-padding) * -1);
+  padding: var(--combobox-option-padding);
+}
+
+[data-mantine-color-scheme='light'] .mantine-raltP2G, [data-mantine-color-scheme='light'] .mantine-dRrkbFg {
+    --_footer-border-color: var(--mantine-color-gray-2);
+}
+
+[data-mantine-color-scheme='dark'] .mantine-raltP2G, [data-mantine-color-scheme='dark'] .mantine-dRrkbFg {
+    --_footer-border-color: var(--mantine-color-dark-4);
+}
+
+.mantine-dRrkbFg {
+  border-top-width: calc(0.0625rem * var(--mantine-scale));
+  margin-top: var(--combobox-padding);
+  margin-bottom: calc(var(--combobox-padding) * -1);
+}
+
+.mantine-raltP2G {
+  border-bottom-width: calc(0.0625rem * var(--mantine-scale));
+  margin-bottom: var(--combobox-padding);
+  margin-top: calc(var(--combobox-padding) * -1);
+}
+
 .mantine-jQnfD5v {
   --container-size-xs: calc(33.75rem * var(--mantine-scale));
   --container-size-sm: calc(45rem * var(--mantine-scale));
@@ -4372,15 +4635,3 @@ fieldset:disabled .mantine-NegW5ug:not([data-inverted]),
   [data-mantine-color-scheme='dark'] .mantine-yPad50m blockquote {
       background-color: var(--mantine-color-dark-8);
 }
-
-.mantine-27MenJe {
-  border: 0;
-  clip: rect(0 0 0 0);
-  height: 1px;
-  width: 1px;
-  margin: -1px;
-  overflow: hidden;
-  padding: 0;
-  position: absolute;
-  white-space: nowrap;
-}

package/esm/index.js

@@ -59,6 +59,13 @@ export { factory } from './core/factory/factory.js';
 export { polymorphicFactory } from './core/factory/polymorphic-factory.js';
 export { createPolymorphicComponent } from './core/factory/create-polymorphic-component.js';
 export { DirectionContext, DirectionProvider, useDirection } from './core/DirectionProvider/DirectionProvider.js';
+export { UnstyledButton } from './components/UnstyledButton/UnstyledButton.js';
+export { VisuallyHidden } from './components/VisuallyHidden/VisuallyHidden.js';
+export { Accordion } from './components/Accordion/Accordion.js';
+export { AccordionChevron } from './components/Accordion/AccordionChevron.js';
+export { AccordionItem } from './components/Accordion/AccordionItem/AccordionItem.js';
+export { AccordionPanel } from './components/Accordion/AccordionPanel/AccordionPanel.js';
+export { AccordionControl } from './components/Accordion/AccordionControl/AccordionControl.js';
 export { ActionIcon } from './components/ActionIcon/ActionIcon.js';
 export { ActionIconGroup } from './components/ActionIcon/ActionIconGroup/ActionIconGroup.js';
 export { Affix } from './components/Affix/Affix.js';
@@ -175,6 +182,4 @@ export { transitions as MANTINE_TRANSITIONS } from './components/Transition/tran
 export { Transition } from './components/Transition/Transition.js';
 export { getTransitionProps } from './components/Transition/get-transition-props/get-transition-props.js';
 export { TypographyStylesProvider } from './components/TypographyStylesProvider/TypographyStylesProvider.js';
-export { UnstyledButton } from './components/UnstyledButton/UnstyledButton.js';
-export { VisuallyHidden } from './components/VisuallyHidden/VisuallyHidden.js';
 //# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

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

@@ -0,0 +1,23 @@
+/// <reference types="react" />
+import { GetStylesApi } from '../../core';
+import { AccordionChevronPosition, AccordionHeadingOrder } from './Accordion.types';
+import type { AccordionFactory } from './Accordion';
+interface AccordionContext {
+    loop: boolean | undefined;
+    transitionDuration: number | undefined;
+    disableChevronRotation: boolean | undefined;
+    chevronPosition: AccordionChevronPosition | undefined;
+    order: AccordionHeadingOrder | undefined;
+    chevron: React.ReactNode;
+    onChange(value: string): void;
+    isItemActive(value: string): boolean;
+    getControlId(value: string): string;
+    getRegionId(value: string): string;
+    getStyles: GetStylesApi<AccordionFactory>;
+    variant: string | undefined;
+}
+export declare const AccordionProvider: ({ children, value }: {
+    value: AccordionContext;
+    children: import("react").ReactNode;
+}) => JSX.Element, useAccordionContext: () => AccordionContext;
+export {};

package/lib/components/Accordion/Accordion.d.ts

@@ -0,0 +1,73 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory, MantineRadius, MantineThemeComponent } from '../../core';
+import { AccordionChevron } from './AccordionChevron';
+import { AccordionChevronPosition, AccordionHeadingOrder, AccordionValue } from './Accordion.types';
+export type AccordionStylesNames = 'root' | 'content' | 'item' | 'panel' | 'icon' | 'chevron' | 'label' | 'itemTitle' | 'control';
+export type AccordionVariant = 'default' | 'contained' | 'filled' | 'separated';
+export type AccordionCssVariables = {
+    root: '--accordion-transition-duration' | '--accordion-chevron-size' | '--accordion-radius';
+};
+export interface AccordionProps<Multiple extends boolean = false> extends BoxProps, StylesApiProps<AccordionFactory>, ElementProps<'div', 'value' | 'defaultValue' | 'onChange'> {
+    /** Determines whether multiple items can be opened at a time, `false` by default */
+    multiple?: Multiple;
+    /** Value for controlled component */
+    value?: AccordionValue<Multiple>;
+    /** Default value for uncontrolled component */
+    defaultValue?: AccordionValue<Multiple>;
+    /** Called when value changes */
+    onChange?(value: AccordionValue<Multiple>): void;
+    /** Determines whether arrow key presses should loop though items (first to last and last to first), `true` by default */
+    loop?: boolean;
+    /** Transition duration in ms, `200` by default */
+    transitionDuration?: number;
+    /** Determines whether chevron rotation should be disabled, `false` by default */
+    disableChevronRotation?: boolean;
+    /** Position of the chevron relative to the item label, `right` by default */
+    chevronPosition?: AccordionChevronPosition;
+    /** Size of the chevron icon container, `24` by default */
+    chevronSize?: number | string;
+    /** Heading order, has no effect on visuals */
+    order?: AccordionHeadingOrder;
+    /** Custom chevron icon that will be used in all items */
+    chevron?: React.ReactNode;
+    /** Key of `theme.radius` or any valid CSS value to set border-radius. Numbers are converted to rem. `theme.defaultRadius` by default. */
+    radius?: MantineRadius | (string & {}) | number;
+}
+export type AccordionFactory = Factory<{
+    props: AccordionProps;
+    ref: HTMLDivElement;
+    stylesNames: AccordionStylesNames;
+    vars: AccordionCssVariables;
+    variant: AccordionVariant;
+}>;
+export declare function Accordion<Multiple extends boolean = false>(_props: AccordionProps<Multiple>): JSX.Element;
+export declare namespace Accordion {
+    var extend: (c: import("../../core/factory/factory").ExtendsRootComponent<{
+        props: AccordionProps<false>;
+        ref: HTMLDivElement;
+        stylesNames: AccordionStylesNames;
+        vars: AccordionCssVariables;
+        variant: AccordionVariant;
+    }>) => MantineThemeComponent;
+    var classes: any;
+    var displayName: string;
+    var Item: import("../../core").MantineComponent<{
+        props: import("./AccordionItem/AccordionItem").AccordionItemProps;
+        ref: HTMLDivElement;
+        stylesNames: "item";
+        compound: true;
+    }>;
+    var Panel: import("../../core").MantineComponent<{
+        props: import("./AccordionPanel/AccordionPanel").AccordionPanelProps;
+        ref: HTMLDivElement;
+        stylesNames: import("./AccordionPanel/AccordionPanel").AccordionPanelStylesNames;
+        compound: true;
+    }>;
+    var Control: import("../../core").MantineComponent<{
+        props: import("./AccordionControl/AccordionControl").AccordionControlProps;
+        ref: HTMLButtonElement;
+        stylesNames: import("./AccordionControl/AccordionControl").AccordionControlStylesNames;
+        compound: true;
+    }>;
+    var Chevron: typeof AccordionChevron;
+}

package/lib/components/Accordion/Accordion.types.d.ts

@@ -0,0 +1,3 @@
+export type AccordionValue<Multiple extends boolean> = Multiple extends true ? string[] : string | null;
+export type AccordionHeadingOrder = 2 | 3 | 4 | 5 | 6;
+export type AccordionChevronPosition = 'left' | 'right';

package/lib/components/Accordion/AccordionChevron.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+export interface AccordionChevronProps extends React.ComponentPropsWithoutRef<'svg'> {
+    /** Controls `width` and `height` of the icon, `16` by default */
+    size?: number | string;
+}
+export declare function AccordionChevron({ style, size, ...others }: AccordionChevronProps): JSX.Element;
+export declare namespace AccordionChevron {
+    var displayName: string;
+}

package/lib/components/Accordion/AccordionControl/AccordionControl.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type AccordionControlStylesNames = 'control' | 'chevron' | 'label' | 'itemTitle' | 'icon';
+export interface AccordionControlProps extends BoxProps, StylesApiProps<AccordionControlFactory>, ElementProps<'button'> {
+    /** Disables control button */
+    disabled?: boolean;
+    /** Custom chevron icon */
+    chevron?: React.ReactNode;
+    /** Control label */
+    children?: React.ReactNode;
+    /** Icon displayed next to the label */
+    icon?: React.ReactNode;
+}
+export type AccordionControlFactory = Factory<{
+    props: AccordionControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: AccordionControlStylesNames;
+    compound: true;
+}>;
+export declare const AccordionControl: import("../../../core").MantineComponent<{
+    props: AccordionControlProps;
+    ref: HTMLButtonElement;
+    stylesNames: AccordionControlStylesNames;
+    compound: true;
+}>;

package/lib/components/Accordion/AccordionItem/AccordionItem.d.ts

@@ -0,0 +1,18 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type AccordionItemStylesNames = 'item';
+export interface AccordionItemProps extends BoxProps, StylesApiProps<AccordionItemFactory>, ElementProps<'div'> {
+    /** Value that is used to manage accordion state */
+    value: string;
+}
+export type AccordionItemFactory = Factory<{
+    props: AccordionItemProps;
+    ref: HTMLDivElement;
+    stylesNames: AccordionItemStylesNames;
+    compound: true;
+}>;
+export declare const AccordionItem: import("../../../core").MantineComponent<{
+    props: AccordionItemProps;
+    ref: HTMLDivElement;
+    stylesNames: AccordionItemStylesNames;
+    compound: true;
+}>;

package/lib/components/Accordion/AccordionItem.context.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="react" />
+interface AccordionItemContext {
+    value: string;
+}
+export declare const AccordionItemProvider: ({ children, value }: {
+    value: AccordionItemContext;
+    children: import("react").ReactNode;
+}) => JSX.Element, useAccordionItemContext: () => AccordionItemContext;
+export {};

package/lib/components/Accordion/AccordionPanel/AccordionPanel.d.ts

@@ -0,0 +1,16 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type AccordionPanelStylesNames = 'panel' | 'content';
+export interface AccordionPanelProps extends BoxProps, StylesApiProps<AccordionPanelFactory>, ElementProps<'div', 'onTransitionEnd'> {
+}
+export type AccordionPanelFactory = Factory<{
+    props: AccordionPanelProps;
+    ref: HTMLDivElement;
+    stylesNames: AccordionPanelStylesNames;
+    compound: true;
+}>;
+export declare const AccordionPanel: import("../../../core").MantineComponent<{
+    props: AccordionPanelProps;
+    ref: HTMLDivElement;
+    stylesNames: AccordionPanelStylesNames;
+    compound: true;
+}>;

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

@@ -0,0 +1,11 @@
+export { Accordion } from './Accordion';
+export { AccordionChevron } from './AccordionChevron';
+export { AccordionItem } from './AccordionItem/AccordionItem';
+export { AccordionPanel } from './AccordionPanel/AccordionPanel';
+export { AccordionControl } from './AccordionControl/AccordionControl';
+export type { AccordionProps, AccordionStylesNames, AccordionCssVariables, AccordionFactory, AccordionVariant, } from './Accordion';
+export type { AccordionControlProps } from './AccordionControl/AccordionControl';
+export type { AccordionItemProps } from './AccordionItem/AccordionItem';
+export type { AccordionPanelProps } from './AccordionPanel/AccordionPanel';
+export type { AccordionChevronProps } from './AccordionChevron';
+export type { AccordionValue, AccordionHeadingOrder } from './Accordion.types';

package/lib/components/ActionIcon/ActionIcon.d.ts

@@ -14,11 +14,11 @@ export interface ActionIconProps extends BoxProps, StylesApiProps<ActionIconFact
     loading?: boolean;
     /** Props added to the `Loader` component (only visible when `loading` prop is set) */
     loaderProps?: LoaderProps;
-    /** Controls width and height of the button. Numbers are converted. `'md'` by default. */
+    /** Controls width and height of the button. Numbers are converted to rem. `'md'` by default. */
     size?: MantineSize | (string & {}) | number;
     /** Key of `theme.colors` or any valid CSS color. Default value is `theme.primaryColor`.  */
     color?: MantineColor;
-    /** Key of `theme.radius` or any valid CSS value to set border-radius. Numbers are converted. `theme.defaultRadius` by default. */
+    /** Key of `theme.radius` or any valid CSS value to set border-radius. Numbers are converted to rem. `theme.defaultRadius` by default. */
     radius?: MantineRadius | (string & {}) | number;
     /** Gradient data used when `variant="gradient"`, default value is `theme.defaultGradient` */
     gradient?: MantineGradient;

package/lib/components/Checkbox/CheckIcon.d.ts

@@ -2,5 +2,8 @@ import React from 'react';
 export interface CheckboxIconProps extends React.ComponentPropsWithoutRef<'svg'> {
     indeterminate: boolean | undefined;
 }
-export declare function CheckIcon(props: React.ComponentPropsWithoutRef<'svg'>): JSX.Element;
+export interface CheckIconProps extends React.ComponentPropsWithoutRef<'svg'> {
+    size?: number | string;
+}
+export declare function CheckIcon({ size, style, ...others }: CheckIconProps): JSX.Element;
 export declare function CheckboxIcon({ indeterminate, ...others }: CheckboxIconProps): JSX.Element;

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

@@ -1,6 +1,6 @@
 export { Checkbox } from './Checkbox';
 export { CheckboxGroup } from './CheckboxGroup/CheckboxGroup';
 export { CheckIcon } from './CheckIcon';
-export type { CheckboxIconProps } from './CheckIcon';
+export type { CheckboxIconProps, CheckIconProps } from './CheckIcon';
 export type { CheckboxCssVariables, CheckboxFactory, CheckboxProps, CheckboxStylesNames, CheckboxVariant, } from './Checkbox';
 export type { CheckboxGroupFactory, CheckboxGroupProps, CheckboxGroupStylesNames, CheckboxGroupVariant, } from './CheckboxGroup/CheckboxGroup';

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

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { GetStylesApi } from '../../core';
 import type { ColorPickerFactory } from './ColorPicker';
 interface ColorPickerContextValue {

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

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { GetStylesApi, MantineSize } from '../../core';
 import type { ComboboxFactory } from './Combobox';
 import type { ComboboxOptionProps } from './ComboboxOption/ComboboxOption';

package/lib/components/Combobox/Combobox.d.ts

@@ -9,7 +9,9 @@ import { ComboboxOption, ComboboxOptionProps } from './ComboboxOption/ComboboxOp
 import { ComboboxSearch } from './ComboboxSearch/ComboboxSearch';
 import { ComboboxEmpty } from './ComboboxEmpty/ComboboxEmpty';
 import { ComboboxChevron } from './ComboboxChevron/ComboboxChevron';
-export type ComboboxStylesNames = 'options' | 'dropdown' | 'option' | 'search' | 'empty';
+import { ComboboxFooter } from './ComboboxFooter/ComboboxFooter';
+import { ComboboxHeader } from './ComboboxHeader/ComboboxHeader';
+export type ComboboxStylesNames = 'options' | 'dropdown' | 'option' | 'search' | 'empty' | 'footer' | 'header';
 export type ComboboxCSSVariables = {
     dropdown: '--combobox-option-fz' | '--combobox-padding' | '--combobox-option-padding';
 };
@@ -40,6 +42,8 @@ export type ComboboxFactory = Factory<{
         Search: typeof ComboboxSearch;
         Empty: typeof ComboboxEmpty;
         Chevron: typeof ComboboxChevron;
+        Footer: typeof ComboboxFooter;
+        Header: typeof ComboboxHeader;
     };
 }>;
 export declare function Combobox(_props: ComboboxProps): JSX.Element;
@@ -86,4 +90,16 @@ export declare namespace Combobox {
         stylesNames: "root";
         vars: import("./ComboboxChevron/ComboboxChevron").ComboboxChevronCSSVariables;
     }>;
+    var Footer: import("../../core").MantineComponent<{
+        props: import("./ComboboxFooter/ComboboxFooter").ComboboxFooterProps;
+        ref: HTMLDivElement;
+        stylesNames: "footer";
+        compound: true;
+    }>;
+    var Header: import("../../core").MantineComponent<{
+        props: import("./ComboboxHeader/ComboboxHeader").ComboboxHeaderProps;
+        ref: HTMLDivElement;
+        stylesNames: "header";
+        compound: true;
+    }>;
 }

package/lib/components/Combobox/ComboboxFooter/ComboboxFooter.d.ts

@@ -0,0 +1,16 @@
+import { BoxProps, StylesApiProps, ElementProps, Factory } from '../../../core';
+export type ComboboxFooterStylesNames = 'footer';
+export interface ComboboxFooterProps extends BoxProps, StylesApiProps<ComboboxFooterFactory>, ElementProps<'div'> {
+}
+export type ComboboxFooterFactory = Factory<{
+    props: ComboboxFooterProps;
+    ref: HTMLDivElement;
+    stylesNames: ComboboxFooterStylesNames;
+    compound: true;
+}>;
+export declare const ComboboxFooter: import("../../../core").MantineComponent<{
+    props: ComboboxFooterProps;
+    ref: HTMLDivElement;
+    stylesNames: ComboboxFooterStylesNames;
+    compound: true;
+}>;