@mantine-vue/core 2.0.1 → 2.1.0

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

@@ -0,0 +1,2 @@
+import type { Primitive } from '../../core';
+export type ComboboxPopoverValue<Multiple extends boolean, Value extends Primitive = string> = Multiple extends true ? Value[] : Value | null;

package/lib/components/ComboboxPopover/ComboboxPopoverTarget.d.ts

@@ -0,0 +1,24 @@
+import { type SlotsType, type VNode, type VNodeChild } from 'vue';
+export interface ComboboxPopoverTargetProps {
+    /** Key of the prop that is used to access element ref @default 'ref' */
+    refProp?: string;
+    [key: string]: any;
+}
+export interface ComboboxPopoverTargetSlots {
+    default?: () => VNodeChild;
+}
+export declare const ComboboxPopoverTarget: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    refProp: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    refProp: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    refProp: string;
+}, SlotsType<ComboboxPopoverTargetSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

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

@@ -0,0 +1,5 @@
+export { ComboboxPopover } from './ComboboxPopover';
+export type { ComboboxPopoverProps, ComboboxPopoverSlots, ComboboxPopoverStylesNames, } from './ComboboxPopover';
+export { ComboboxPopoverTarget } from './ComboboxPopoverTarget';
+export type { ComboboxPopoverTargetProps, ComboboxPopoverTargetSlots, } from './ComboboxPopoverTarget';
+export type { ComboboxPopoverValue } from './ComboboxPopover.types';

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

@@ -0,0 +1,4 @@
+export interface DataListContextValue {
+    getStyles: (selector: string, options?: Record<string, any>) => any;
+}
+export declare const provideDataListContext: (value: DataListContextValue) => void, useDataListContext: () => DataListContextValue;

package/lib/components/DataList/DataList.d.ts

@@ -0,0 +1,304 @@
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+import { type MantineSize, type MantineSpacing } from '../../core';
+export type DataListStylesNames = 'root' | 'item' | 'itemLabel' | 'itemValue';
+export type DataListCssVariables = {
+    root: '--data-list-fz' | '--data-list-lh' | '--data-list-gap' | '--data-list-label-width';
+};
+export interface DataListProps {
+    /** Controls `font-size` and `line-height` @default 'sm' */
+    size?: MantineSize | (string & {});
+    /** Key of `theme.spacing` or any valid CSS value to set gap between items @default 'sm' */
+    gap?: MantineSpacing;
+    /** Controls arrangement of label and value within each item. `horizontal` renders label and value side by side, `vertical` stacks label on top of value @default 'horizontal' */
+    orientation?: 'horizontal' | 'vertical';
+    /** Adds border between items @default false */
+    withDivider?: boolean;
+    /** Controls min-width of the label (dt) element, any valid CSS value @default '120px' */
+    labelWidth?: string | number;
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    unstyled?: boolean;
+    mod?: any;
+    [key: string]: any;
+}
+export interface DataListSlots {
+    default?: () => VNodeChild;
+}
+export declare const DataList: import("../..").WithBoxProps<{
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        size: {
+            type: PropType<MantineSize | (string & {})>;
+            default: undefined;
+        };
+        gap: {
+            type: PropType<MantineSpacing>;
+            default: undefined;
+        };
+        orientation: {
+            type: PropType<"horizontal" | "vertical">;
+            default: undefined;
+        };
+        withDivider: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        labelWidth: {
+            type: PropType<string | number>;
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        vars: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {
+        size: MantineSize | (string & {});
+        orientation: "vertical" | "horizontal";
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+        gap: MantineSpacing;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        withDivider: boolean;
+        labelWidth: string | number;
+    }, true, {}, SlotsType<DataListSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        size: {
+            type: PropType<MantineSize | (string & {})>;
+            default: undefined;
+        };
+        gap: {
+            type: PropType<MantineSpacing>;
+            default: undefined;
+        };
+        orientation: {
+            type: PropType<"horizontal" | "vertical">;
+            default: undefined;
+        };
+        withDivider: {
+            type: BooleanConstructor;
+            default: undefined;
+        };
+        labelWidth: {
+            type: PropType<string | number>;
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        vars: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        unstyled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+    }>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, {
+        size: MantineSize | (string & {});
+        orientation: "vertical" | "horizontal";
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+        gap: MantineSpacing;
+        vars: Function | Record<string, any>;
+        unstyled: boolean;
+        withDivider: boolean;
+        labelWidth: string | number;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    size: {
+        type: PropType<MantineSize | (string & {})>;
+        default: undefined;
+    };
+    gap: {
+        type: PropType<MantineSpacing>;
+        default: undefined;
+    };
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: undefined;
+    };
+    withDivider: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    labelWidth: {
+        type: PropType<string | number>;
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    vars: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    unstyled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {
+    size: MantineSize | (string & {});
+    orientation: "vertical" | "horizontal";
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    mod: any;
+    gap: MantineSpacing;
+    vars: Function | Record<string, any>;
+    unstyled: boolean;
+    withDivider: boolean;
+    labelWidth: string | number;
+}, {}, string, SlotsType<DataListSlots>, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & {
+    classes: Record<string, string>;
+    varsResolver: (theme: import("../..").MantineTheme, props: any, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+    Item: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, {
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+    }, SlotsType<import(".").DataListItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    ItemLabel: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, {
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+    }, SlotsType<import(".").DataListItemLabelSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+    ItemValue: import("../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+        [key: string]: any;
+    }>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+        classNames: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        styles: {
+            type: (ObjectConstructor | FunctionConstructor)[];
+            default: undefined;
+        };
+        mod: {
+            type: PropType<any>;
+            default: undefined;
+        };
+    }>> & Readonly<{}>, {
+        classNames: Function | Record<string, any>;
+        styles: Function | Record<string, any>;
+        mod: any;
+    }, SlotsType<import(".").DataListItemValueSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;
+}>;

package/lib/components/DataList/DataListItem/DataListItem.d.ts

@@ -0,0 +1,44 @@
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+export type DataListItemStylesNames = 'item';
+export interface DataListItemProps {
+    classNames?: any;
+    styles?: any;
+    mod?: any;
+    [key: string]: any;
+}
+export interface DataListItemSlots {
+    default?: () => VNodeChild;
+}
+export declare const DataListItem: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    mod: any;
+}, SlotsType<DataListItemSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;

package/lib/components/DataList/DataListItemLabel/DataListItemLabel.d.ts

@@ -0,0 +1,44 @@
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+export type DataListItemLabelStylesNames = 'itemLabel';
+export interface DataListItemLabelProps {
+    classNames?: any;
+    styles?: any;
+    mod?: any;
+    [key: string]: any;
+}
+export interface DataListItemLabelSlots {
+    default?: () => VNodeChild;
+}
+export declare const DataListItemLabel: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    mod: any;
+}, SlotsType<DataListItemLabelSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;

package/lib/components/DataList/DataListItemValue/DataListItemValue.d.ts

@@ -0,0 +1,44 @@
+import { type PropType, type SlotsType, type VNodeChild } from 'vue';
+export type DataListItemValueStylesNames = 'itemValue';
+export interface DataListItemValueProps {
+    classNames?: any;
+    styles?: any;
+    mod?: any;
+    [key: string]: any;
+}
+export interface DataListItemValueSlots {
+    default?: () => VNodeChild;
+}
+export declare const DataListItemValue: import("../../..").WithBoxProps<import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    classNames: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    styles: {
+        type: (ObjectConstructor | FunctionConstructor)[];
+        default: undefined;
+    };
+    mod: {
+        type: PropType<any>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    classNames: Function | Record<string, any>;
+    styles: Function | Record<string, any>;
+    mod: any;
+}, SlotsType<DataListItemValueSlots>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>>;

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

@@ -0,0 +1,10 @@
+export { DataList } from './DataList';
+export type { DataListProps, DataListSlots, DataListStylesNames, DataListCssVariables, } from './DataList';
+export { DataListItem } from './DataListItem/DataListItem';
+export type { DataListItemProps, DataListItemSlots, DataListItemStylesNames, } from './DataListItem/DataListItem';
+export { DataListItemLabel } from './DataListItemLabel/DataListItemLabel';
+export type { DataListItemLabelProps, DataListItemLabelSlots, DataListItemLabelStylesNames, } from './DataListItemLabel/DataListItemLabel';
+export { DataListItemValue } from './DataListItemValue/DataListItemValue';
+export type { DataListItemValueProps, DataListItemValueSlots, DataListItemValueStylesNames, } from './DataListItemValue/DataListItemValue';
+export { useDataListContext } from './DataList.context';
+export type { DataListContextValue } from './DataList.context';

package/lib/components/Dialog/Dialog.d.ts

@@ -160,10 +160,10 @@ export declare const Dialog: import("vue").DefineComponent<import("vue").Extract
     };
 }>> & Readonly<{}>, {
     size: string | number;
+    p: string | number;
     radius: string | number;
     shadow: string;
     onClose: () => void;
-    p: string | number;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
     position: AffixPosition;

package/lib/components/Divider/Divider.d.ts

@@ -84,12 +84,12 @@ export declare const Divider: import("../..").WithBoxProps<import("vue").DefineC
         default: boolean;
     };
 }>> & Readonly<{}>, {
+    label: MantineNode;
+    orientation: "vertical" | "horizontal";
     color: string;
     variant: DividerVariant;
-    label: MantineNode;
     classNames: Function | Record<string, any>;
     styles: Function | Record<string, any>;
-    orientation: "horizontal" | "vertical";
     vars: Function | Record<string, any>;
     unstyled: boolean;
     labelPosition: "center" | "left" | "right";

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

@@ -0,0 +1,5 @@
+export interface EmptyStateContextValue {
+    getStyles: (selector: string, options?: Record<string, any>) => any;
+    withIndicatorBackground: boolean | undefined;
+}
+export declare const provideEmptyStateContext: (value: EmptyStateContextValue) => void, useEmptyStateContext: () => EmptyStateContextValue;