npm - @mantine/core - Versions diffs - 7.13.5-alpha.1 → 7.13.5-alpha.2 - Mend

@mantine/core 7.13.5-alpha.1 → 7.13.5-alpha.2

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2846) hide show

package/lib/core/MantineProvider/theme.types.d.ts ADDED Viewed

@@ -0,0 +1,166 @@
+import type { PartialDeep } from 'type-fest';
+import type { VariantColorsResolver } from './color-functions';
+export interface MantineTheme {
+    /** Controls focus ring styles. Supports the following options:
+     *  - `auto` – focus ring is displayed only when the user navigates with keyboard (default value)
+     *  - `always` – focus ring is displayed when the user navigates with keyboard and mouse
+     *  - `never` – focus ring is always hidden (not recommended)
+     */
+    focusRing: 'auto' | 'always' | 'never';
+    /** Rem units scale, change if you customize font-size of `<html />` element
+     *  default value is `1` (for `100%`/`16px` font-size on `<html />`)
+     */
+    scale: number;
+    /** Determines whether `font-smoothing` property should be set on the body, `true` by default */
+    fontSmoothing: boolean;
+    /** White color */
+    white: string;
+    /** Black color */
+    black: string;
+    /** Object of colors, key is color name, value is an array of at least 10 strings (colors) */
+    colors: MantineThemeColors;
+    /** Index of theme.colors[color].
+     *  Primary shade is used in all components to determine which color from theme.colors[color] should be used.
+     *  Can be either a number (0–9) or an object to specify different color shades for light and dark color schemes.
+     *  Default value `{ light: 6, dark: 8 }`
+     *
+     *  For example,
+     *  { primaryShade: 6 } // shade 6 is used both for dark and light color schemes
+     *  { primaryShade: { light: 6, dark: 7 } } // different shades for dark and light color schemes
+     * */
+    primaryShade: MantineColorShade | MantinePrimaryShade;
+    /** Key of `theme.colors`, hex/rgb/hsl values are not supported.
+     *  Determines which color will be used in all components by default.
+     *  Default value – `blue`.
+     * */
+    primaryColor: string;
+    /** Function to resolve colors based on variant.
+     *  Can be used to deeply customize how colors are applied to `Button`, `ActionIcon`, `ThemeIcon`
+     *  and other components that use colors from theme.
+     * */
+    variantColorResolver: VariantColorsResolver;
+    /** Determines whether text color must be changed based on the given `color` prop in filled variant
+     *  For example, if you pass `color="blue.1"` to Button component, text color will be changed to `var(--mantine-color-black)`
+     *  Default value – `false`
+     * */
+    autoContrast: boolean;
+    /** Determines which luminance value is used to determine if text color should be light or dark.
+     *  Used only if `theme.autoContrast` is set to `true`.
+     *  Default value is `0.3`
+     * */
+    luminanceThreshold: number;
+    /** Font-family used in all components, system fonts by default */
+    fontFamily: string;
+    /** Monospace font-family, used in code and other similar components, system fonts by default  */
+    fontFamilyMonospace: string;
+    /** Controls various styles of h1-h6 elements, used in TypographyStylesProvider and Title components */
+    headings: {
+        fontFamily: string;
+        fontWeight: string;
+        textWrap: 'wrap' | 'nowrap' | 'balance' | 'pretty' | 'stable';
+        sizes: {
+            h1: HeadingStyle;
+            h2: HeadingStyle;
+            h3: HeadingStyle;
+            h4: HeadingStyle;
+            h5: HeadingStyle;
+            h6: HeadingStyle;
+        };
+    };
+    /** Object of values that are used to set `border-radius` in all components that support it */
+    radius: MantineRadiusValues;
+    /** Key of `theme.radius` or any valid CSS value. Default `border-radius` used by most components */
+    defaultRadius: MantineRadius;
+    /** Object of values that are used to set various CSS properties that control spacing between elements */
+    spacing: MantineSpacingValues;
+    /** Object of values that are used to control `font-size` property in all components */
+    fontSizes: MantineFontSizesValues;
+    /** Object of values that are used to control `line-height` property in `Text` component */
+    lineHeights: MantineLineHeightValues;
+    /** Object of values that are used to control breakpoints in all components,
+     *  values are expected to be defined in em
+     * */
+    breakpoints: MantineBreakpointsValues;
+    /** Object of values that are used to add `box-shadow` styles to components that support `shadow` prop */
+    shadows: MantineShadowsValues;
+    /** Determines whether user OS settings to reduce motion should be respected, `false` by default */
+    respectReducedMotion: boolean;
+    /** Determines which cursor type will be used for interactive elements
+     * - `default` – cursor that is used by native HTML elements, for example, `input[type="checkbox"]` has `cursor: default` styles
+     * - `pointer` – sets `cursor: pointer` on interactive elements that do not have these styles by default
+     */
+    cursorType: 'default' | 'pointer';
+    /** Default gradient configuration for components that support `variant="gradient"` */
+    defaultGradient: MantineGradient;
+    /** Class added to the elements that have active styles, for example, `Button` and `ActionIcon` */
+    activeClassName: string;
+    /** Class added to the elements that have focus styles, for example, `Button` or `ActionIcon`.
+     *  Overrides `theme.focusRing` property.
+     */
+    focusClassName: string;
+    /** Allows adding `classNames`, `styles` and `defaultProps` to any component */
+    components: MantineThemeComponents;
+    /** Any other properties that you want to access with the theme objects */
+    other: MantineThemeOther;
+}
+export type MantineColorScheme = 'light' | 'dark' | 'auto';
+export type MantineThemeOverride = PartialDeep<MantineTheme>;
+export type MantineStylesRecord = Record<string, React.CSSProperties>;
+export interface MantineThemeComponent {
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    defaultProps?: any;
+}
+export type MantineThemeComponents = Record<string, MantineThemeComponent>;
+export interface HeadingStyle {
+    fontSize: string;
+    fontWeight?: string;
+    lineHeight: string;
+}
+export type MantineSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export type MantineBreakpointsValues = Record<MantineSize | (string & {}), string>;
+export type MantineFontSizesValues = Record<MantineSize | (string & {}), string>;
+export type MantineRadiusValues = Record<MantineSize | (string & {}), string>;
+export type MantineSpacingValues = Record<MantineSize | (string & {}), string>;
+export type MantineShadowsValues = Record<MantineSize | (string & {}), string>;
+export type MantineLineHeightValues = Record<MantineSize | (string & {}), string>;
+export type MantineBreakpoint = keyof MantineBreakpointsValues;
+export type MantineFontSize = keyof MantineFontSizesValues;
+export type MantineRadius = keyof MantineRadiusValues | (string & {}) | number;
+export type MantineSpacing = keyof MantineSpacingValues | (string & {}) | number;
+export type MantineShadow = keyof MantineShadowsValues | (string & {});
+export type MantineLineHeight = keyof MantineLineHeightValues;
+export interface MantineThemeOther {
+    [key: string]: any;
+}
+export interface MantineGradient {
+    from: string;
+    to: string;
+    deg?: number;
+}
+export type MantineColorsTuple = readonly [
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    ...string[]
+];
+export type MantineColorShade = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface MantinePrimaryShade {
+    light: MantineColorShade;
+    dark: MantineColorShade;
+}
+export type DefaultMantineColor = 'dark' | 'gray' | 'red' | 'pink' | 'grape' | 'violet' | 'indigo' | 'blue' | 'cyan' | 'green' | 'lime' | 'yellow' | 'orange' | 'teal' | (string & {});
+export interface MantineThemeColorsOverride {
+}
+export type MantineThemeColors = MantineThemeColorsOverride extends {
+    colors: Record<infer CustomColors, MantineColorsTuple>;
+} ? Record<CustomColors, MantineColorsTuple> : Record<DefaultMantineColor, MantineColorsTuple>;
+export type MantineColor = keyof MantineThemeColors;

package/lib/core/MantineProvider/use-mantine-color-scheme/index.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export { useMantineColorScheme } from './use-mantine-color-scheme';
+export { useProviderColorScheme } from './use-provider-color-scheme';
+export { useComputedColorScheme } from './use-computed-color-scheme';

package/lib/core/MantineProvider/use-mantine-color-scheme/use-computed-color-scheme.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import { UseMediaQueryOptions } from '@mantine/hooks';
2	+ export declare function useComputedColorScheme(defaultValue?: 'light' \| 'dark', options?: UseMediaQueryOptions): "dark" \| "light";

package/lib/core/MantineProvider/use-mantine-color-scheme/use-mantine-color-scheme.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { MantineColorScheme } from '../theme.types';
+export declare function useMantineColorScheme({ keepTransitions }?: {
+    keepTransitions?: boolean;
+}): {
+    colorScheme: MantineColorScheme;
+    setColorScheme: (value: MantineColorScheme) => void;
+    clearColorScheme: () => void;
+    toggleColorScheme: () => void;
+};

package/lib/core/MantineProvider/use-mantine-color-scheme/use-provider-color-scheme.d.ts ADDED Viewed

@@ -0,0 +1,14 @@
+import type { MantineColorSchemeManager } from '../color-scheme-managers';
+import type { MantineColorScheme } from '../theme.types';
+interface UseProviderColorSchemeOptions {
+    manager: MantineColorSchemeManager;
+    defaultColorScheme: MantineColorScheme;
+    forceColorScheme: 'light' | 'dark' | undefined;
+    getRootElement: () => HTMLElement | undefined;
+}
+export declare function useProviderColorScheme({ manager, defaultColorScheme, getRootElement, forceColorScheme, }: UseProviderColorSchemeOptions): {
+    colorScheme: MantineColorScheme;
+    setColorScheme: (colorScheme: MantineColorScheme) => void;
+    clearColorScheme: () => void;
+};
+export {};

package/lib/core/MantineProvider/use-matches/use-matches.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+import { UseMediaQueryOptions } from '@mantine/hooks';
+import { MantineBreakpoint } from '../theme.types';
+type UseMatchesInput<T> = Partial<Record<MantineBreakpoint, T>>;
+export declare function useMatches<T>(payload: UseMatchesInput<T>, options?: UseMediaQueryOptions): T;
+export {};

package/lib/core/MantineProvider/use-props/use-props.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+export declare function useProps<T extends Record<string, any>, U extends Partial<T> = {}>(component: string, defaultProps: U, props: T): T & {
+    [Key in Extract<keyof T, keyof U>]-?: U[Key] | NonNullable<T[Key]>;
+};

package/lib/core/MantineProvider/use-respect-reduce-motion/index.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ export { useRespectReduceMotion } from './use-respect-reduce-motion';

package/lib/core/MantineProvider/use-respect-reduce-motion/use-respect-reduce-motion.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+interface UseRespectReduceMotionOptions {
+    respectReducedMotion: boolean;
+    getRootElement: () => HTMLElement | undefined;
+}
+export declare function useRespectReduceMotion({ respectReducedMotion, getRootElement, }: UseRespectReduceMotionOptions): void;
+export {};

package/lib/core/factory/create-factory.d.ts ADDED Viewed

@@ -0,0 +1,4 @@
+import { FactoryPayload } from './factory';
+import { PolymorphicFactoryPayload } from './polymorphic-factory';
+export type Factory<Payload extends FactoryPayload> = Payload;
+export type PolymorphicFactory<Payload extends PolymorphicFactoryPayload> = Payload;

package/lib/core/factory/create-polymorphic-component.d.ts ADDED Viewed

@@ -0,0 +1,23 @@
+type ExtendedProps<Props = {}, OverrideProps = {}> = OverrideProps & Omit<Props, keyof OverrideProps>;
+type ElementType = keyof JSX.IntrinsicElements | React.JSXElementConstructor<any>;
+type PropsOf<C extends ElementType> = JSX.LibraryManagedAttributes<C, React.ComponentPropsWithoutRef<C>>;
+type ComponentProp<C> = {
+    component?: C;
+};
+type InheritedProps<C extends ElementType, Props = {}> = ExtendedProps<PropsOf<C>, Props>;
+export type PolymorphicRef<C> = C extends React.ElementType ? React.ComponentPropsWithRef<C>['ref'] : never;
+export type PolymorphicComponentProps<C, Props = {}> = C extends React.ElementType ? InheritedProps<C, Props & ComponentProp<C>> & {
+    ref?: PolymorphicRef<C>;
+    renderRoot?: (props: any) => any;
+} : Props & {
+    component: React.ElementType;
+    renderRoot?: (props: Record<string, any>) => any;
+};
+export declare function createPolymorphicComponent<ComponentDefaultType, Props, StaticComponents = Record<string, never>>(component: any): (<C = ComponentDefaultType>(props: PolymorphicComponentProps<C, Props>) => React.ReactElement) & Omit<import("react").FunctionComponent<(Props & ComponentProp<any> & Omit<Omit<any, "ref">, "component" | keyof Props> & {
+    ref?: any;
+    renderRoot?: (props: any) => any;
+}) | (Props & {
+    component: React.ElementType;
+    renderRoot?: (props: Record<string, any>) => any;
+})>, never> & StaticComponents;
+export {};

package/lib/core/factory/factory.d.ts ADDED Viewed

@@ -0,0 +1,44 @@
+import type { MantineThemeComponent } from '../MantineProvider';
+import type { ClassNames, PartialVarsResolver, Styles } from '../styles-api';
+export type DataAttributes = Record<`data-${string}`, any>;
+export interface FactoryPayload {
+    props: Record<string, any>;
+    ctx?: any;
+    ref?: any;
+    stylesNames?: string;
+    vars?: any;
+    variant?: string;
+    staticComponents?: Record<string, any>;
+    compound?: boolean;
+}
+export interface ExtendCompoundComponent<Payload extends FactoryPayload> {
+    defaultProps?: Partial<Payload['props']> & DataAttributes;
+}
+export interface ExtendsRootComponent<Payload extends FactoryPayload> {
+    defaultProps?: Partial<Payload['props']> & DataAttributes;
+    classNames?: ClassNames<Payload>;
+    styles?: Styles<Payload>;
+    vars?: PartialVarsResolver<Payload>;
+}
+export type ExtendComponent<Payload extends FactoryPayload> = Payload['compound'] extends true ? ExtendCompoundComponent<Payload> : ExtendsRootComponent<Payload>;
+export type StaticComponents<Input> = Input extends Record<string, any> ? Input : Record<string, never>;
+export interface ThemeExtend<Payload extends FactoryPayload> {
+    extend: (input: ExtendComponent<Payload>) => MantineThemeComponent;
+}
+export type ComponentClasses<Payload extends FactoryPayload> = {
+    classes: Payload['stylesNames'] extends string ? Record<string, string> : never;
+};
+export type MantineComponentStaticProperties<Payload extends FactoryPayload> = ThemeExtend<Payload> & ComponentClasses<Payload> & StaticComponents<Payload['staticComponents']> & FactoryComponentWithProps<Payload>;
+export type FactoryComponentWithProps<Payload extends FactoryPayload> = {
+    withProps: (props: Payload['props']) => React.ForwardRefExoticComponent<Payload['props'] & React.RefAttributes<Payload['ref']> & {
+        component?: any;
+        renderRoot?: (props: Record<string, any>) => React.ReactNode;
+    }>;
+};
+export type MantineComponent<Payload extends FactoryPayload> = React.ForwardRefExoticComponent<Payload['props'] & React.RefAttributes<Payload['ref']> & {
+    component?: any;
+    renderRoot?: (props: Record<string, any>) => React.ReactNode;
+}> & MantineComponentStaticProperties<Payload>;
+export declare function identity<T>(value: T): T;
+export declare function getWithProps<T, Props>(Component: T): (props: Partial<Props>) => T;
+export declare function factory<Payload extends FactoryPayload>(ui: React.ForwardRefRenderFunction<Payload['ref'], Payload['props']>): MantineComponent<Payload>;

package/lib/core/factory/index.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+export { factory, getWithProps } from './factory';
+export { polymorphicFactory } from './polymorphic-factory';
+export { createPolymorphicComponent } from './create-polymorphic-component';
+export type { FactoryPayload, ExtendComponent, MantineComponent, MantineComponentStaticProperties, FactoryComponentWithProps, } from './factory';
+export type { PolymorphicComponentProps, PolymorphicRef } from './create-polymorphic-component';
+export type { Factory, PolymorphicFactory } from './create-factory';

package/lib/core/factory/polymorphic-factory.d.ts ADDED Viewed

@@ -0,0 +1,18 @@
+import { PolymorphicComponentProps } from './create-polymorphic-component';
+import { ComponentClasses, FactoryPayload, StaticComponents, ThemeExtend } from './factory';
+export interface PolymorphicFactoryPayload extends FactoryPayload {
+    defaultComponent: any;
+    defaultRef: any;
+}
+export type PolymorphicComponentWithProps<Payload extends PolymorphicFactoryPayload> = {
+    withProps: <C = Payload['defaultComponent']>(fixedProps: PolymorphicComponentProps<C, Payload['props']>) => <L = C>(props: PolymorphicComponentProps<L, Payload['props']>) => React.ReactElement;
+};
+export declare function polymorphicFactory<Payload extends PolymorphicFactoryPayload>(ui: React.ForwardRefRenderFunction<Payload['defaultRef'], Payload['props']>): (<C = Payload["defaultComponent"]>(props: PolymorphicComponentProps<C, Payload["props"]>) => React.ReactElement) & Omit<import("react").FunctionComponent<(Payload["props"] & {
+    component?: any;
+} & Omit<Omit<any, "ref">, "component" | keyof Payload["props"]> & {
+    ref?: any;
+    renderRoot?: (props: any) => any;
+}) | (Payload["props"] & {
+    component: React.ElementType;
+    renderRoot?: (props: Record<string, any>) => any;
+})>, never> & ThemeExtend<Payload> & ComponentClasses<Payload> & PolymorphicComponentWithProps<Payload> & StaticComponents<Payload["staticComponents"]>;

package/lib/core/index.d.ts ADDED Viewed

@@ -0,0 +1,7 @@
+export * from './utils';
+export * from './styles-api';
+export * from './MantineProvider';
+export * from './InlineStyles';
+export * from './Box';
+export * from './factory';
+export * from './DirectionProvider';

package/lib/core/styles-api/create-vars-resolver/create-vars-resolver.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { CssVariable } from '../../Box';
+import { FactoryPayload } from '../../factory';
+import { MantineTheme } from '../../MantineProvider';
+export type TransformVars<V> = {
+    [Key in keyof V]: V[Key] extends CssVariable ? Record<V[Key], string | undefined> : never;
+};
+export type PartialTransformVars<V> = {
+    [Key in keyof V]: V[Key] extends CssVariable ? Partial<Record<V[Key], string | undefined>> : never;
+};
+export type VarsResolver<Payload extends FactoryPayload> = (theme: MantineTheme, props: Payload['props'], ctx: Payload['ctx']) => TransformVars<Payload['vars']>;
+export type PartialVarsResolver<Payload extends FactoryPayload> = (theme: MantineTheme, props: Payload['props'], ctx: Payload['ctx']) => PartialTransformVars<Payload['vars']>;
+export declare function createVarsResolver<Payload extends FactoryPayload>(resolver: VarsResolver<Payload>): VarsResolver<Payload>;

package/lib/core/styles-api/index.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+export { createVarsResolver } from './create-vars-resolver/create-vars-resolver';
+export { resolveClassNames } from './use-styles/get-class-name/resolve-class-names/resolve-class-names';
+export { resolveStyles } from './use-styles/get-style/resolve-styles/resolve-styles';
+export { useResolvedStylesApi } from './use-resolved-styles-api/use-resolved-styles-api';
+export { FOCUS_CLASS_NAMES } from './use-styles/get-class-name/get-global-class-names/get-global-class-names';
+export * from './styles-api.types';
+export * from './use-styles/use-styles';
+export type { VarsResolver, PartialVarsResolver, TransformVars, PartialTransformVars, } from './create-vars-resolver/create-vars-resolver';

package/lib/core/styles-api/styles-api.types.d.ts ADDED Viewed

@@ -0,0 +1,35 @@
+import type { CSSProperties, MantineStyleProp } from '../Box';
+import type { FactoryPayload } from '../factory';
+import type { MantineTheme } from '../MantineProvider';
+import { PartialVarsResolver } from './create-vars-resolver/create-vars-resolver';
+export interface GetStylesApiOptions {
+    className?: string;
+    style?: MantineStyleProp;
+    focusable?: boolean;
+    active?: boolean;
+    classNames?: ClassNames<{
+        props: any;
+        stylesNames: string;
+    }>;
+    styles?: Styles<{
+        props: any;
+        stylesNames: string;
+    }>;
+    variant?: string;
+    props?: Record<string, any>;
+    withStaticClass?: boolean;
+}
+export type StylesApiRecord<Payload extends FactoryPayload, DataType> = Payload['compound'] extends true ? Payload['stylesNames'] extends string ? StylesRecord<Payload['stylesNames'], DataType> : never : Payload['stylesNames'] extends string ? StylesRecord<Payload['stylesNames'], DataType> | ((theme: MantineTheme, props: Payload['props'], ctx: Payload['ctx']) => StylesRecord<Payload['stylesNames'], DataType>) : never;
+export type Styles<Payload extends FactoryPayload> = StylesApiRecord<Payload, CSSProperties>;
+export type ClassNames<Payload extends FactoryPayload> = StylesApiRecord<Payload, string>;
+export type ClassNamesArray<Payload extends FactoryPayload> = (StylesApiRecord<Payload, string> | undefined)[];
+export type StylesRecord<StylesNames extends string, Payload> = Partial<Record<StylesNames, Payload>>;
+export interface StylesApiProps<Payload extends FactoryPayload> {
+    unstyled?: boolean;
+    variant?: Payload['variant'] extends string ? Payload['variant'] | (string & {}) : string;
+    classNames?: ClassNames<Payload>;
+    styles?: Styles<Payload>;
+    vars?: PartialVarsResolver<Payload>;
+}
+export interface CompoundStylesApiProps<Payload extends FactoryPayload> extends Omit<StylesApiProps<Payload>, 'unstyled'> {
+}

package/lib/core/styles-api/use-resolved-styles-api/use-resolved-styles-api.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import { FactoryPayload } from '../../factory';
+import { ClassNames, Styles } from '../styles-api.types';
+export interface UseResolvedStylesApiInput<Payload extends FactoryPayload> {
+    classNames: ClassNames<Payload> | undefined;
+    styles: Styles<Payload> | undefined;
+    props: Record<string, any>;
+    stylesCtx?: Record<string, any>;
+}
+export declare function useResolvedStylesApi<Payload extends FactoryPayload>({ classNames, styles, props, stylesCtx, }: UseResolvedStylesApiInput<Payload>): {
+    resolvedClassNames: Partial<Record<string, string>>;
+    resolvedStyles: Record<string, any>;
+};

package/lib/core/styles-api/use-styles/get-class-name/get-class-name.d.ts ADDED Viewed

@@ -0,0 +1,38 @@
+import { MantineTheme } from '../../../MantineProvider';
+import { GetStylesApiOptions } from '../../styles-api.types';
+type __ClassNames = undefined | Partial<Record<string, string>> | ((theme: MantineTheme, props: Record<string, any>, ctx: Record<string, any> | undefined) => Partial<Record<string, string>>);
+export type _ClassNames = __ClassNames | __ClassNames[];
+export interface GetClassNameOptions {
+    /** Theme object, resolved by hook */
+    theme: MantineTheme;
+    /** Options for specified selector, may include `classNames` or `className` */
+    options: GetStylesApiOptions | undefined;
+    /** Name of the component which is used to get `classNames` from `theme.components` */
+    themeName: string[];
+    /** Class part specified in `getStyles` */
+    selector: string;
+    /** Prefix for all class names, resolved by hook, `mantine` by default */
+    classNamesPrefix: string;
+    /** `classNames` specified in the hook, only resolved `classNames[selector]` is added to the list */
+    classNames: _ClassNames;
+    /** Classes object, usually imported from `*.module.css` */
+    classes: Record<string, string>;
+    /** Determines whether classes from `classes` should be added to the list */
+    unstyled: boolean | undefined;
+    /** `className` specified in the hook, added to the list if `selector` is `rootSelector` */
+    className: string | undefined;
+    /** `rootSelector` specified in the hook, determines whether `className` should be added to the list */
+    rootSelector: string;
+    /** Component props, used as context for `classNames` and `options.classNames` */
+    props: Record<string, any>;
+    /** Component styles context, used as context for `classNames` and `options.classNames` */
+    stylesCtx?: Record<string, any> | undefined;
+    /** Determines whether static classes should be added */
+    withStaticClasses?: boolean;
+    /** If set, removes all Mantine classes */
+    headless?: boolean;
+    /** `styles` prop transformed into classes with CSS-in-JS library, for example, emotion */
+    transformedStyles?: Record<string, string>[];
+}
+export declare function getClassName({ theme, options, themeName, selector, classNamesPrefix, classNames, classes, unstyled, className, rootSelector, props, stylesCtx, withStaticClasses, headless, transformedStyles, }: GetClassNameOptions): string;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-global-class-names/get-global-class-names.d.ts ADDED Viewed

@@ -0,0 +1,15 @@
+import { MantineTheme } from '../../../../MantineProvider';
+import { GetStylesApiOptions } from '../../../styles-api.types';
+interface GetGlobalClassNamesOptions {
+    theme: MantineTheme;
+    unstyled: boolean | undefined;
+    options: GetStylesApiOptions | undefined;
+}
+export declare const FOCUS_CLASS_NAMES: {
+    readonly always: "mantine-focus-always";
+    readonly auto: "mantine-focus-auto";
+    readonly never: "mantine-focus-never";
+};
+/** Returns classes that are defined globally (focus and active styles) based on options */
+export declare function getGlobalClassNames({ theme, options, unstyled }: GetGlobalClassNamesOptions): string;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-options-class-names/get-options-class-names.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+import { GetStylesApiOptions } from '../../../styles-api.types';
+import { ResolveClassNamesInput } from '../resolve-class-names/resolve-class-names';
+interface GetOptionsClassNamesInput extends Omit<ResolveClassNamesInput, 'classNames'> {
+    selector: string;
+    options: GetStylesApiOptions | undefined;
+}
+export declare function getOptionsClassNames({ selector, stylesCtx, options, props, theme, }: GetOptionsClassNamesInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-resolved-class-names/get-resolved-class-names.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { ResolveClassNamesInput } from '../resolve-class-names/resolve-class-names';
+interface GetResolvedClassNamesOptions extends ResolveClassNamesInput {
+    selector: string;
+}
+export declare function getResolvedClassNames({ selector, stylesCtx, theme, classNames, props, }: GetResolvedClassNamesOptions): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-root-class-name/get-root-class-name.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+interface GetRootClassNameInput {
+    rootSelector: string;
+    selector: string;
+    className: string | undefined;
+}
+/** Adds `className` to the list if given selector is root */
+export declare function getRootClassName({ rootSelector, selector, className }: GetRootClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-selector-class-name/get-selector-class-name.d.ts ADDED Viewed

@@ -0,0 +1,8 @@
+interface GetSelectorClassNameInput {
+    selector: string;
+    classes: Record<string, string>;
+    unstyled: boolean | undefined;
+}
+/** Returns class for given selector from library styles (`*.module.css`) */
+export declare function getSelectorClassName({ selector, classes, unstyled }: GetSelectorClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-static-class-names/get-static-class-names.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+interface GetStaticClassNamesInput {
+    themeName: string[];
+    selector: string;
+    classNamesPrefix: string;
+    withStaticClass?: boolean;
+}
+/** Returns static component classes, for example, `.mantine-Input-wrapper` */
+export declare function getStaticClassNames({ themeName, classNamesPrefix, selector, withStaticClass, }: GetStaticClassNamesInput): string[];
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-theme-class-names/get-theme-class-names.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { MantineTheme } from '../../../../MantineProvider';
+interface GetThemeClassNamesOptions {
+    theme: MantineTheme;
+    themeName: string[];
+    selector: string;
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+}
+export declare function getThemeClassNames({ themeName, theme, selector, props, stylesCtx, }: GetThemeClassNamesOptions): (string | undefined)[];
+export {};

package/lib/core/styles-api/use-styles/get-class-name/get-variant-class-name/get-variant-class-name.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { GetStylesApiOptions } from '../../../styles-api.types';
+interface GetVariantClassNameInput {
+    options: GetStylesApiOptions | undefined;
+    classes: Record<string, string>;
+    selector: string;
+    unstyled: boolean | undefined;
+}
+/** Returns variant className, variant is always separated from selector with `--`, for example, `tab--default` */
+export declare function getVariantClassName({ options, classes, selector, unstyled, }: GetVariantClassNameInput): string | undefined;
+export {};

package/lib/core/styles-api/use-styles/get-class-name/resolve-class-names/resolve-class-names.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { MantineTheme } from '../../../../MantineProvider';
+import type { _ClassNames } from '../get-class-name';
+export interface ResolveClassNamesInput {
+    theme: MantineTheme;
+    classNames: _ClassNames;
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+}
+export declare function resolveClassNames({ theme, classNames, props, stylesCtx }: ResolveClassNamesInput): Partial<Record<string, string>>;

package/lib/core/styles-api/use-styles/get-style/get-style.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import { CSSProperties } from 'react';
+import { MantineStyleProp } from '../../../Box';
+import { MantineTheme } from '../../../MantineProvider';
+import { GetStylesApiOptions } from '../../styles-api.types';
+import { VarsResolver } from './resolve-vars/resolve-vars';
+export type _Styles = undefined | Partial<Record<string, CSSProperties>> | ((theme: MantineTheme, props: Record<string, any>, ctx: Record<string, any> | undefined) => Partial<Record<string, CSSProperties>>);
+export interface GetStyleInput {
+    theme: MantineTheme;
+    themeName: string[];
+    selector: string;
+    rootSelector: string;
+    options: GetStylesApiOptions | undefined;
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+    styles: _Styles;
+    style: MantineStyleProp | undefined;
+    vars: VarsResolver | undefined;
+    varsResolver: VarsResolver | undefined;
+    headless?: boolean;
+    withStylesTransform?: boolean;
+}
+export declare function getStyle({ theme, themeName, selector, options, props, stylesCtx, rootSelector, styles, style, vars, varsResolver, headless, withStylesTransform, }: GetStyleInput): CSSProperties;

package/lib/core/styles-api/use-styles/get-style/get-theme-styles/get-theme-styles.d.ts ADDED Viewed

@@ -0,0 +1,10 @@
+import { MantineTheme } from '../../../../MantineProvider';
+interface GetThemeStylesOptions {
+    theme: MantineTheme;
+    themeName: string[];
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+    selector: string;
+}
+export declare function getThemeStyles({ theme, themeName, props, stylesCtx, selector, }: GetThemeStylesOptions): any;
+export {};

package/lib/core/styles-api/use-styles/get-style/resolve-style/resolve-style.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import { CSSProperties } from 'react';
+import { MantineStyleProp } from '../../../../Box';
+import { MantineTheme } from '../../../../MantineProvider';
+interface ResolveStyleInput {
+    style: MantineStyleProp | undefined;
+    theme: MantineTheme;
+}
+export declare function resolveStyle({ style, theme }: ResolveStyleInput): CSSProperties;
+export {};

package/lib/core/styles-api/use-styles/get-style/resolve-styles/resolve-styles.d.ts ADDED Viewed

@@ -0,0 +1,9 @@
+import type { MantineTheme } from '../../../../MantineProvider';
+import type { _Styles } from '../get-style';
+export interface ResolveStylesInput {
+    theme: MantineTheme;
+    styles: _Styles | _Styles[];
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+}
+export declare function resolveStyles({ theme, styles, props, stylesCtx }: ResolveStylesInput): Record<string, any>;

package/lib/core/styles-api/use-styles/get-style/resolve-vars/merge-vars.d.ts ADDED Viewed

@@ -0,0 +1,3 @@
+import { CssVariable } from '../../../../Box';
+export type ResolvedVars = Partial<Record<string, Record<CssVariable, string | undefined>>>;
+export declare function mergeVars(vars: (ResolvedVars | undefined)[]): Partial<Record<string, Record<`--${string}`, string | undefined>>>;

package/lib/core/styles-api/use-styles/get-style/resolve-vars/resolve-vars.d.ts ADDED Viewed

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import { CssVariable } from '../../../../Box';
+import { MantineTheme } from '../../../../MantineProvider';
+type ResolvedVars = Partial<Record<string, Record<CssVariable, string>>>;
+export type VarsResolver = (theme: MantineTheme, props: Record<string, any>, stylesCtx: Record<string, any> | undefined) => ResolvedVars;
+interface ResolveVarsInput {
+    vars: VarsResolver | undefined;
+    varsResolver: VarsResolver | undefined;
+    theme: MantineTheme;
+    props: Record<string, any>;
+    stylesCtx: Record<string, any> | undefined;
+    selector: string;
+    themeName: string[];
+    headless?: boolean;
+}
+export declare function resolveVars({ vars, varsResolver, theme, props, stylesCtx, selector, themeName, headless, }: ResolveVarsInput): CSSProperties;
+export {};