@mantine-vue/core 1.1.1

package/lib/core/MantineProvider/MantineThemeProvider.d.ts

@@ -0,0 +1,235 @@
+import { type PropType } from 'vue';
+import type { MantineTheme, MantineThemeOverride } from './theme.types';
+export declare function useMantineTheme(): import("vue").ComputedRef<MantineTheme>;
+export declare function useSafeMantineTheme(): import("vue").ComputedRef<MantineTheme>;
+export declare const MantineThemeProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    inherit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<MantineThemeOverride>;
+        default: undefined;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    inherit: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    theme: {
+        type: PropType<MantineThemeOverride>;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    theme: {
+        focusRing?: "auto" | "always" | "never" | undefined;
+        scale?: number | undefined;
+        fontSmoothing?: boolean | undefined;
+        white?: string | undefined;
+        black?: string | undefined;
+        colors?: {
+            [x: string & {}]: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            dark?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            gray?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            red?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            pink?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            grape?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            violet?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            indigo?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            blue?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            cyan?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            green?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            lime?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            yellow?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            orange?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+            teal?: readonly [(string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, (string | undefined)?, ...(string | undefined)[]] | undefined;
+        } | undefined;
+        primaryShade?: import("./theme.types").MantineColorShade | {
+            light?: import("./theme.types").MantineColorShade | undefined;
+            dark?: import("./theme.types").MantineColorShade | undefined;
+        } | undefined;
+        primaryColor?: string | undefined;
+        variantColorResolver?: import("./theme.types").VariantColorsResolver | undefined;
+        autoContrast?: boolean | undefined;
+        luminanceThreshold?: number | undefined;
+        fontFamily?: string | undefined;
+        fontFamilyMonospace?: string | undefined;
+        headings?: {
+            fontFamily?: string | undefined;
+            fontWeight?: string | undefined;
+            textWrap?: "wrap" | "nowrap" | "balance" | "pretty" | "stable" | undefined;
+            sizes?: {
+                h1?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+                h2?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+                h3?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+                h4?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+                h5?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+                h6?: {
+                    fontSize?: string | undefined;
+                    lineHeight?: string | undefined;
+                    fontWeight?: string | undefined;
+                } | undefined;
+            } | undefined;
+        } | undefined;
+        radius?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        defaultRadius?: number | import("./theme.types").MantineSize | {
+            readonly [x: number]: string | undefined;
+            toString?: (() => string) | undefined;
+            charAt?: ((pos: number) => string) | undefined;
+            charCodeAt?: ((index: number) => number) | undefined;
+            concat?: ((...strings: string[]) => string) | undefined;
+            indexOf?: ((searchString: string, position?: number) => number) | undefined;
+            lastIndexOf?: ((searchString: string, position?: number) => number) | undefined;
+            localeCompare?: {
+                (that: string): number;
+                (that: string, locales?: string | string[], options?: Intl.CollatorOptions): number;
+                (that: string, locales?: Intl.LocalesArgument, options?: Intl.CollatorOptions): number;
+            } | undefined;
+            match?: {
+                (regexp: string | RegExp): RegExpMatchArray | null;
+                (matcher: {
+                    [Symbol.match](string: string): RegExpMatchArray | null;
+                }): RegExpMatchArray | null;
+            } | undefined;
+            replace?: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replaceValue: string): string;
+                }, replaceValue: string): string;
+                (searchValue: {
+                    [Symbol.replace](string: string, replacer: (substring: string, ...args: any[]) => string): string;
+                }, replacer: (substring: string, ...args: any[]) => string): string;
+            } | undefined;
+            search?: {
+                (regexp: string | RegExp): number;
+                (searcher: {
+                    [Symbol.search](string: string): number;
+                }): number;
+            } | undefined;
+            slice?: ((start?: number, end?: number) => string) | undefined;
+            split?: {
+                (separator: string | RegExp, limit?: number): string[];
+                (splitter: {
+                    [Symbol.split](string: string, limit?: number): string[];
+                }, limit?: number): string[];
+            } | undefined;
+            substring?: ((start: number, end?: number) => string) | undefined;
+            toLowerCase?: (() => string) | undefined;
+            toLocaleLowerCase?: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            } | undefined;
+            toUpperCase?: (() => string) | undefined;
+            toLocaleUpperCase?: {
+                (locales?: string | string[]): string;
+                (locales?: Intl.LocalesArgument): string;
+            } | undefined;
+            trim?: (() => string) | undefined;
+            readonly length?: number | undefined;
+            substr?: ((from: number, length?: number) => string) | undefined;
+            valueOf?: (() => string) | undefined;
+            codePointAt?: ((pos: number) => number | undefined) | undefined;
+            includes?: ((searchString: string, position?: number) => boolean) | undefined;
+            endsWith?: ((searchString: string, endPosition?: number) => boolean) | undefined;
+            normalize?: {
+                (form: "NFC" | "NFD" | "NFKC" | "NFKD"): string;
+                (form?: string): string;
+            } | undefined;
+            repeat?: ((count: number) => string) | undefined;
+            startsWith?: ((searchString: string, position?: number) => boolean) | undefined;
+            anchor?: ((name: string) => string) | undefined;
+            big?: (() => string) | undefined;
+            blink?: (() => string) | undefined;
+            bold?: (() => string) | undefined;
+            fixed?: (() => string) | undefined;
+            fontcolor?: ((color: string) => string) | undefined;
+            fontsize?: {
+                (size: number): string;
+                (size: string): string;
+            } | undefined;
+            italics?: (() => string) | undefined;
+            link?: ((url: string) => string) | undefined;
+            small?: (() => string) | undefined;
+            strike?: (() => string) | undefined;
+            sub?: (() => string) | undefined;
+            sup?: (() => string) | undefined;
+            padStart?: ((maxLength: number, fillString?: string) => string) | undefined;
+            padEnd?: ((maxLength: number, fillString?: string) => string) | undefined;
+            trimEnd?: (() => string) | undefined;
+            trimStart?: (() => string) | undefined;
+            trimLeft?: (() => string) | undefined;
+            trimRight?: (() => string) | undefined;
+            matchAll?: ((regexp: RegExp) => RegExpStringIterator<RegExpExecArray>) | undefined;
+            replaceAll?: {
+                (searchValue: string | RegExp, replaceValue: string): string;
+                (searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
+            } | undefined;
+            at?: ((index: number) => string | undefined) | undefined;
+            [Symbol.iterator]?: (() => StringIterator<string>) | undefined;
+        } | undefined;
+        spacing?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        fontSizes?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        lineHeights?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        fontWeights?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        breakpoints?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        shadows?: {
+            [x: string]: string | undefined;
+        } | undefined;
+        respectReducedMotion?: boolean | undefined;
+        cursorType?: "default" | "pointer" | undefined;
+        defaultGradient?: {
+            from?: string | undefined;
+            to?: string | undefined;
+            deg?: number | undefined;
+        } | undefined;
+        activeClassName?: string | undefined;
+        focusClassName?: string | undefined;
+        components?: {
+            [x: string]: {
+                classNames?: any;
+                styles?: any;
+                vars?: any;
+                defaultProps?: any;
+            } | undefined;
+        } | undefined;
+        other?: {
+            [x: string]: any;
+        } | undefined;
+    };
+    inherit: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;

package/lib/core/MantineProvider/color-functions.d.ts

@@ -0,0 +1,53 @@
+import type { MantineColorScheme, MantineColorShade, MantineColorsTuple, MantineGradient, MantineTheme, VariantColorsResolver } from './theme.types';
+export declare function getPrimaryShade(theme: MantineTheme, colorScheme: MantineColorScheme): MantineColorShade;
+export interface RGBA {
+    r: number;
+    g: number;
+    b: number;
+    a: number;
+}
+export declare function toRgba(color: string): RGBA;
+export declare function rgba(color: string, alpha: number): string;
+export declare const alpha: typeof rgba;
+export declare function darken(color: string, alphaValue: number): string;
+export declare function lighten(color: string, alphaValue: number): string;
+export declare function luminance(color: string): number;
+export declare function isLightColor(color: string, luminanceThreshold?: number): boolean;
+export declare function colorsTuple(input: string | string[]): MantineColorsTuple;
+interface VirtualColorInput {
+    dark: string;
+    light: string;
+    name: string;
+}
+export type VirtualColor = MantineColorsTuple & {
+    'mantine-virtual-color': true;
+    name: string;
+    dark: string;
+    light: string;
+};
+export declare function virtualColor(input: VirtualColorInput): MantineColorsTuple;
+export declare function isVirtualColor(value: unknown): value is VirtualColor;
+export interface ParseThemeColorResult {
+    color: string;
+    value: string;
+    shade: MantineColorShade | undefined;
+    variable: string | undefined;
+    isThemeColor: boolean;
+    isLight: boolean;
+}
+export declare function parseThemeColor({ color, theme, colorScheme, }: {
+    color: unknown;
+    theme: MantineTheme;
+    colorScheme?: MantineColorScheme;
+}): ParseThemeColorResult;
+export declare function getThemeColor(color: string | undefined | null, theme: MantineTheme, colorScheme?: MantineColorScheme): string;
+export declare function getGradient(gradient: MantineGradient | undefined, theme: MantineTheme): string;
+export declare function getAutoContrastValue(autoContrast: boolean | undefined, theme: MantineTheme): boolean;
+export declare function getContrastColor({ color, theme, autoContrast, }: {
+    color?: string | null;
+    theme: MantineTheme;
+    autoContrast?: boolean | null;
+}): "var(--mantine-color-white)" | "var(--mantine-color-black)";
+export declare function getPrimaryContrastColor(theme: MantineTheme, colorScheme: 'light' | 'dark'): "var(--mantine-color-white)" | "var(--mantine-color-black)";
+export declare const defaultVariantColorsResolver: VariantColorsResolver;
+export {};

package/lib/core/MantineProvider/css-variables.d.ts

@@ -0,0 +1,14 @@
+import type { MantineTheme } from './theme.types';
+export interface ConvertCSSVariablesInput {
+    variables: Record<string, string>;
+    light?: Record<string, string>;
+    dark?: Record<string, string>;
+}
+export type CSSVariablesResolver = (theme: MantineTheme) => ConvertCSSVariablesInput;
+export declare const defaultCssVariablesResolver: CSSVariablesResolver;
+export declare function getMergedVariables({ theme, generator, }: {
+    theme: MantineTheme;
+    generator?: CSSVariablesResolver;
+}): ConvertCSSVariablesInput;
+export declare function cssVariablesObjectToString(variables: Record<string, string | undefined>): string;
+export declare function convertCssVariables(input: ConvertCSSVariablesInput, selector?: string): string;

package/lib/core/MantineProvider/default-colors.d.ts

@@ -0,0 +1,2 @@
+import type { MantineThemeColors } from './theme.types';
+export declare const DEFAULT_COLORS: MantineThemeColors;

package/lib/core/MantineProvider/default-theme.d.ts

@@ -0,0 +1,2 @@
+import type { MantineTheme } from './theme.types';
+export declare const DEFAULT_THEME: MantineTheme;

package/lib/core/MantineProvider/index.d.ts

@@ -0,0 +1,10 @@
+export * from './theme.types';
+export * from './default-theme';
+export * from './default-colors';
+export * from './color-functions';
+export * from './merge-mantine-theme';
+export * from './css-variables';
+export * from './Mantine.context';
+export * from './MantineThemeProvider';
+export * from './MantineProvider';
+export * from './use-props';

package/lib/core/MantineProvider/merge-mantine-theme.d.ts

@@ -0,0 +1,5 @@
+import type { MantineTheme, MantineThemeOverride } from './theme.types';
+export declare const INVALID_PRIMARY_COLOR_ERROR = "[@mantine-vue/core] MantineProvider: Invalid theme.primaryColor, it accepts only key of theme.colors";
+export declare const INVALID_PRIMARY_SHADE_ERROR = "[@mantine-vue/core] MantineProvider: Invalid theme.primaryShade, it accepts only 0-9 integers or an object { light: 0-9, dark: 0-9 }";
+export declare function validateMantineTheme(theme: MantineTheme): asserts theme is MantineTheme;
+export declare function mergeMantineTheme(currentTheme: MantineTheme, themeOverride?: MantineThemeOverride): MantineTheme;

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

@@ -0,0 +1,107 @@
+import type { CSSProperties } from 'vue';
+export type PartialDeep<T> = T extends (...args: any[]) => any ? T : T extends object ? {
+    [K in keyof T]?: PartialDeep<T[K]>;
+} : T;
+export type MantineColorScheme = 'light' | 'dark' | 'auto';
+export type MantineColorShade = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type MantineSize = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+export interface MantineThemeSizesOverride {
+}
+type CustomThemeSize<Section extends string> = MantineThemeSizesOverride extends Record<Section, Record<infer CustomSize, string>> ? CustomSize : MantineSize;
+export type MantineRadius = CustomThemeSize<'radius'> | (string & {}) | number;
+export type MantineSpacing = CustomThemeSize<'spacing'> | (string & {}) | number;
+export type MantineColorsTuple = readonly [
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    string,
+    ...string[]
+];
+export interface MantinePrimaryShade {
+    light: MantineColorShade;
+    dark: MantineColorShade;
+}
+export interface MantineGradient {
+    from: string;
+    to: string;
+    deg?: number;
+}
+export type DefaultMantineColor = 'dark' | 'gray' | 'red' | 'pink' | 'grape' | 'violet' | 'indigo' | 'blue' | 'cyan' | 'green' | 'lime' | 'yellow' | 'orange' | 'teal';
+export interface MantineThemeColorsOverride {
+}
+type ThemeColorName = MantineThemeColorsOverride extends {
+    colors: Record<infer CustomColor, MantineColorsTuple>;
+} ? CustomColor : DefaultMantineColor;
+export type MantineThemeColors = Record<ThemeColorName | (string & {}), MantineColorsTuple>;
+export type MantineColor = ThemeColorName | `${ThemeColorName & string}.${MantineColorShade}` | 'white' | 'black' | 'dimmed' | 'bright' | (string & {});
+export type MantineThemeOther = Record<string, any>;
+export type MantineStylesRecord = Record<string, CSSProperties>;
+export interface VariantColorResolverInput {
+    color?: string;
+    theme: MantineTheme;
+    variant: string;
+    gradient?: MantineGradient;
+    autoContrast?: boolean;
+}
+export interface VariantColorsResolverResult {
+    background: string;
+    hover: string;
+    hoverColor?: string;
+    color: string;
+    border: string;
+}
+export type VariantColorsResolver = (input: VariantColorResolverInput) => VariantColorsResolverResult;
+export interface MantineThemeComponent {
+    classNames?: any;
+    styles?: any;
+    vars?: any;
+    defaultProps?: any;
+}
+export interface MantineTheme {
+    focusRing: 'auto' | 'always' | 'never';
+    scale: number;
+    fontSmoothing: boolean;
+    white: string;
+    black: string;
+    colors: MantineThemeColors;
+    primaryShade: MantineColorShade | MantinePrimaryShade;
+    primaryColor: string;
+    variantColorResolver: VariantColorsResolver;
+    autoContrast: boolean;
+    luminanceThreshold: number;
+    fontFamily: string;
+    fontFamilyMonospace: string;
+    headings: {
+        fontFamily: string;
+        fontWeight: string;
+        textWrap: 'wrap' | 'nowrap' | 'balance' | 'pretty' | 'stable';
+        sizes: Record<'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6', {
+            fontSize: string;
+            lineHeight: string;
+            fontWeight?: string;
+        }>;
+    };
+    radius: Record<string, string>;
+    defaultRadius: MantineRadius;
+    spacing: Record<string, string>;
+    fontSizes: Record<string, string>;
+    lineHeights: Record<string, string>;
+    fontWeights: Record<string, string>;
+    breakpoints: Record<string, string>;
+    shadows: Record<string, string>;
+    respectReducedMotion: boolean;
+    cursorType: 'default' | 'pointer';
+    defaultGradient: MantineGradient;
+    activeClassName: string;
+    focusClassName: string;
+    components: Record<string, MantineThemeComponent>;
+    other: MantineThemeOther;
+}
+export type MantineThemeOverride = PartialDeep<MantineTheme>;
+export {};

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

@@ -0,0 +1 @@
+export declare function useProps<Props extends Record<string, any>>(component: string, defaultProps: Partial<Props> | null, props: Props): Props;

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

@@ -0,0 +1,28 @@
+import { type PropType } from 'vue';
+export interface VueFactoryPayload<Props extends Record<string, any> = Record<string, any>> {
+    name: string;
+    props?: Record<string, any>;
+    setup: (props: Props, ctx: {
+        attrs: Record<string, unknown>;
+        slots: any;
+        emit: any;
+        ref: any;
+    }) => any;
+}
+export declare function factory<Props extends Record<string, any>>(payload: VueFactoryPayload<Props>): import("vue").DefineComponent<{}, () => any, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {
+    [x: string]: any;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export interface FactoryBoxProps {
+    component?: string;
+    class?: any;
+    style?: any;
+}
+export declare const polymorphicProps: {
+    component: {
+        type: PropType<string>;
+        default: undefined;
+    };
+};
+export declare function renderPolymorphic(component: string | undefined, props: Record<string, any>, children?: any): import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>;

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

@@ -0,0 +1,4 @@
+export * from './factory';
+export * from './polymorphic-factory';
+export * from './with-box-props';
+export * from './use-forwarded-ref';

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

@@ -0,0 +1 @@
+export { factory as polymorphicFactory, renderPolymorphic } from './factory';

package/lib/core/factory/use-forwarded-ref.d.ts

@@ -0,0 +1,39 @@
+import { type Ref } from 'vue';
+/**
+ * Vue has no built-in equivalent of React's `forwardRef`: a `ref` attached to
+ * a component (e.g. `<Button ref="x" />`) always resolves to the component's
+ * public instance proxy, never to the DOM node it renders.
+ *
+ * This helper reads the `ref` the *parent* attached to the current component
+ * instance and keeps it in sync with `elementRef` -- the component's own ref
+ * to its rendered root element -- so the parent's ref ends up pointing at the
+ * real DOM node instead, matching React Mantine's `factory()` behavior.
+ *
+ * It relies on a documented-but-internal detail of Vue 3: whenever a `ref`
+ * prop is a string, a `Ref`, or a function, Vue normalizes `vnode.ref` into
+ * an `{ i, r, k, f }` descriptor before the component ever sees it, where `r`
+ * is the original value the parent passed (see `normalizeRef` in
+ * `@vue/runtime-core`'s `vnode.ts`). This shape has been stable across Vue
+ * 3.x, but it isn't public API, so treat this as a best-effort forwarder --
+ * if a future Vue version changes it, this degrades to a no-op (the ref
+ * simply won't forward), not a crash.
+ *
+ * Usage inside a component's `setup()`, once `elementRef` is bound to the
+ * component's real root element:
+ *
+ * ```ts
+ * setup(props, { attrs }) {
+ *   const elementRef = ref<HTMLDivElement | null>(null)
+ *   useForwardedRef(elementRef)
+ *   return () => h('div', { ...attrs, ref: elementRef })
+ * }
+ * ```
+ *
+ * For multi-layer components (e.g. `Button` renders `UnstyledButton`, which
+ * renders `Box`, which renders the native element), every layer needs to
+ * call `useForwardedRef` and attach its own `elementRef` to whatever it
+ * renders -- each layer intercepts the ref passed by its parent and
+ * re-targets it one level down, the same way React's `forwardRef` calls are
+ * threaded explicitly through each wrapper.
+ */
+export declare function useForwardedRef<T extends Element>(elementRef: Ref<T | null>): void;

package/lib/core/factory/with-box-props.d.ts

@@ -0,0 +1,18 @@
+import type { BoxProps } from '../Box';
+/**
+ * Additively widens a Vue component's template `$props` with `BoxProps` so that
+ * Mantine style props (m, mt, p, w, h, bg, c, …) and Box layout props
+ * (hiddenFrom, visibleFrom, mod, …) are available for autocomplete/IntelliSense
+ * and type-checking.
+ *
+ * Runtime is untouched: these props already pass through to the underlying Box
+ * as fall-through attributes. The merge happens at the instance level
+ * (`InstanceType<C> & { $props: BoxProps }`) so the component's own props,
+ * slots, emits and static members (e.g. `Group`) are all preserved.
+ */
+export type WithBoxProps<C> = C & {
+    new (): (C extends new (...args: any[]) => infer I ? I : object) & {
+        $props: BoxProps;
+    };
+};
+export declare function withBoxProps<C>(component: C): WithBoxProps<C>;

package/lib/core/index.d.ts

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

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

@@ -0,0 +1,2 @@
+import type { MantineTheme } from '../MantineProvider';
+export declare function createVarsResolver<Props>(resolver: (theme: MantineTheme, props: Props, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>): (theme: MantineTheme, props: Props, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;

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

@@ -0,0 +1,3 @@
+export * from './styles-api.types';
+export * from './create-vars-resolver';
+export * from './use-styles';

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

@@ -0,0 +1,27 @@
+import type { CSSProperties } from 'vue';
+import type { MantineTheme } from '../MantineProvider';
+export type ClassNames<Payload = any> = Record<string, string> | ((theme: MantineTheme, payload: Payload) => Record<string, string>);
+export type Styles<Payload = any> = Record<string, CSSProperties> | ((theme: MantineTheme, payload: Payload) => Record<string, CSSProperties>);
+export type Vars<Payload = any> = Record<string, Record<string, string | undefined>> | ((theme: MantineTheme, payload: Payload) => Record<string, Record<string, string | undefined>>);
+export interface StylesApiProps<Payload = any> {
+    classNames?: ClassNames<Payload>;
+    styles?: Styles<Payload>;
+    vars?: Vars<Payload>;
+    unstyled?: boolean;
+}
+export interface UseStylesInput<Payload = any> {
+    name: string | (string | undefined)[];
+    classes?: Record<string, string>;
+    props?: Record<string, any>;
+    stylesCtx?: Record<string, any>;
+    className?: any;
+    style?: CSSProperties | CSSProperties[];
+    classNames?: ClassNames<Payload>;
+    styles?: Styles<Payload>;
+    vars?: Vars<Payload>;
+    varsResolver?: (theme: MantineTheme, props: Record<string, any>, ctx: Record<string, any>) => Record<string, Record<string, string | undefined>>;
+    rootSelector?: string;
+    selector?: string;
+    unstyled?: boolean;
+    attributes?: Record<string, Record<string, any>>;
+}

package/lib/core/styles-api/use-styles.d.ts

@@ -0,0 +1,14 @@
+import type { UseStylesInput } from './styles-api.types';
+export declare function useStyles<Payload = any>(input: UseStylesInput<Payload>): (selector: string, options?: {
+    active?: boolean;
+    focusable?: boolean;
+    className?: any;
+    style?: any;
+    classNames?: UseStylesInput<Payload>["classNames"];
+    styles?: UseStylesInput<Payload>["styles"];
+    props?: Record<string, any>;
+    variant?: string;
+}) => {
+    class: any[];
+    style: any;
+};

package/lib/core/types.d.ts

@@ -0,0 +1,24 @@
+import type { CSSProperties, Component, Ref } from 'vue';
+import type { MantineTheme, MantineThemeOverride } from './MantineProvider';
+export type MantineStyle = CSSProperties;
+export type MantineClassNames = Record<string, string>;
+export type MantineStyles = Record<string, MantineStyle>;
+export type MantineVars = Record<string, Record<string, string | undefined>>;
+export interface MantineComponentTheme {
+    classNames?: MantineClassNames | ((theme: MantineTheme, props: any) => MantineClassNames);
+    styles?: MantineStyles | ((theme: MantineTheme, props: any) => MantineStyles);
+    vars?: MantineVars | ((theme: MantineTheme, props: any) => MantineVars);
+    defaultProps?: Record<string, any>;
+}
+export interface MantineProviderVNodeProps {
+    theme?: MantineThemeOverride;
+}
+export interface MantineVueComponentFactoryPayload<Props = Record<string, any>> {
+    name: string;
+    props?: Props;
+    render: (payload: {
+        props: Props;
+        ref: Ref<any>;
+    }) => any;
+}
+export type MantineVueComponent = Component;

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

@@ -0,0 +1,4 @@
+import { type InjectionKey } from 'vue';
+export * from '@mantine-vue/utils';
+export declare function createSafeInjectionContext<T>(errorMessage: string): readonly [(value: T) => void, () => T & ({} | undefined), InjectionKey<T>];
+export declare const createSafeContext: typeof createSafeInjectionContext;

package/lib/index.d.mts

@@ -0,0 +1,2 @@
+export * from './core/index';
+export * from './components/index';

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from './core/index';
+export * from './components/index';