@ledgerhq/lumen-ui-rnative 0.0.44 → 0.0.45

package/dist/src/lib/Components/Text/Text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Text.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/Text/Text.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,cAAc,CAAC;AAC9C,OAAO,EAAoB,KAAK,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAE7E;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAA2B,CAAC;AAE7C,MAAM,MAAM,SAAS,GAAG,mBAAmB,CAAC"}

package/dist/src/lib/Components/Text/Text.stories.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Text.stories.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/Text/Text.stories.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAE9B,QAAA,MAAM,IAAI,EAAE,IAAI,CAAC,OAAO,IAAI,CAY3B,CAAC;AAEF,eAAe,IAAI,CAAC;AACpB,KAAK,KAAK,GAAG,QAAQ,CAAC,OAAO,IAAI,CAAC,CAAC;AAEnC,eAAO,MAAM,IAAI,EAAE,KAiBlB,CAAC"}

package/dist/src/lib/Components/Text/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/Text/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,YAAY,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAC"}

package/dist/src/lib/Components/_ToRemove/ToRemove.d.ts

@@ -1,9 +0,0 @@
-type Variant = 'primary' | 'secondary' | 'error';
-type ToRemoveProps = {
-    variant?: Variant;
-    title?: string;
-    description?: string;
-};
-export declare const ToRemove: ({ variant, title, description, }: ToRemoveProps) => import("react/jsx-runtime").JSX.Element;
-export {};
-//# sourceMappingURL=ToRemove.d.ts.map

package/dist/src/lib/Components/_ToRemove/ToRemove.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ToRemove.d.ts","sourceRoot":"","sources":["../../../../../src/lib/Components/_ToRemove/ToRemove.tsx"],"names":[],"mappings":"AAIA,KAAK,OAAO,GAAG,SAAS,GAAG,WAAW,GAAG,OAAO,CAAC;AAyCjD,KAAK,aAAa,GAAG;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,kCAItB,aAAa,4CASf,CAAC"}

package/dist/src/lib/Components/_ToRemove/ToRemove.js

@@ -1,43 +0,0 @@
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { Text, View } from 'react-native';
-import { LumenStyleSheet } from '../../../styles/LumenStyleSheet';
-const useToRemoveStyles = (variant) => {
-    return LumenStyleSheet.useCreate((theme) => {
-        const bgColorMap = {
-            primary: theme.colors.bg.accent,
-            secondary: theme.colors.bg.surface,
-            error: theme.colors.bg.error,
-        };
-        const textColorMap = {
-            primary: theme.colors.text.onAccent,
-            secondary: theme.colors.text.base,
-            error: theme.colors.text.error,
-        };
-        return {
-            container: {
-                backgroundColor: bgColorMap[variant],
-                padding: theme.spacings.s16,
-                borderRadius: theme.borderRadius.md,
-                gap: theme.spacings.s8,
-                boxShadow: theme.shadows.xl,
-                shadowColor: theme.colors.border.error,
-                elevation: 4,
-                width: 200,
-                minHeight: 80,
-            },
-            title: {
-                color: textColorMap[variant],
-                ...theme.typographies.body1SemiBold,
-            },
-            description: {
-                color: textColorMap[variant],
-                ...theme.typographies.body2,
-                opacity: 0.8,
-            },
-        };
-    });
-};
-export const ToRemove = ({ variant = 'primary', title = 'Card Title', description = 'Description text', }) => {
-    const styles = useToRemoveStyles(variant);
-    return (_jsxs(View, { style: styles.container, children: [_jsx(Text, { style: styles.title, children: title }), _jsx(Text, { style: styles.description, children: description })] }));
-};

package/dist/src/styles/utils/styleVarianceAuthority.d.ts

@@ -1,30 +0,0 @@
-import type { ImageStyle, TextStyle, ViewStyle } from 'react-native';
-type StyleValue = ViewStyle | TextStyle | ImageStyle;
-type VariantsConfig = Record<string, Record<string, StyleValue>>;
-type CompoundVariantConditions<V extends VariantsConfig> = {
-    [K in keyof V]?: keyof V[K];
-};
-type AtLeastOneCondition<V extends VariantsConfig> = {
-    [K in keyof V]: Required<Pick<CompoundVariantConditions<V>, K>> & Partial<Omit<CompoundVariantConditions<V>, K>>;
-}[keyof V];
-type CompoundVariant<V extends VariantsConfig> = AtLeastOneCondition<V> & {
-    style: StyleValue;
-};
-type VariantConfig<V extends VariantsConfig> = {
-    base?: StyleValue;
-    variants?: V;
-    compoundVariants?: CompoundVariant<V>[];
-    defaultVariants?: {
-        [K in keyof V]?: keyof V[K];
-    };
-};
-type VariantPropsInput<V extends VariantsConfig> = {
-    [K in keyof V]?: keyof V[K];
-};
-/**
- * Extract variant props type from an sva instance
- */
-export type VariantProps<T> = T extends (props?: infer P) => StyleValue ? P : never;
-export declare const sva: <V extends VariantsConfig>(config: VariantConfig<V>) => (props?: VariantPropsInput<V>) => StyleValue;
-export {};
-//# sourceMappingURL=styleVarianceAuthority.d.ts.map

package/dist/src/styles/utils/styleVarianceAuthority.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"styleVarianceAuthority.d.ts","sourceRoot":"","sources":["../../../../src/styles/utils/styleVarianceAuthority.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AAErE,KAAK,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;AAErD,KAAK,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC,CAAC;AAEjE,KAAK,yBAAyB,CAAC,CAAC,SAAS,cAAc,IAAI;KACxD,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5B,CAAC;AAGF,KAAK,mBAAmB,CAAC,CAAC,SAAS,cAAc,IAAI;KAClD,CAAC,IAAI,MAAM,CAAC,GAAG,QAAQ,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,GAC7D,OAAO,CAAC,IAAI,CAAC,yBAAyB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;CACjD,CAAC,MAAM,CAAC,CAAC,CAAC;AAEX,KAAK,eAAe,CAAC,CAAC,SAAS,cAAc,IAAI,mBAAmB,CAAC,CAAC,CAAC,GAAG;IACxE,KAAK,EAAE,UAAU,CAAC;CACnB,CAAC;AAEF,KAAK,aAAa,CAAC,CAAC,SAAS,cAAc,IAAI;IAC7C,IAAI,CAAC,EAAE,UAAU,CAAC;IAClB,QAAQ,CAAC,EAAE,CAAC,CAAC;IACb,gBAAgB,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC,EAAE,CAAC;IACxC,eAAe,CAAC,EAAE;SAAG,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;KAAE,CAAC;CACnD,CAAC;AAEF,KAAK,iBAAiB,CAAC,CAAC,SAAS,cAAc,IAAI;KAChD,CAAC,IAAI,MAAM,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;CAC5B,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC,KAAK,UAAU,GACnE,CAAC,GACD,KAAK,CAAC;AAkDV,eAAO,MAAM,GAAG,GAAI,CAAC,SAAS,cAAc,EAAE,QAAQ,aAAa,CAAC,CAAC,CAAC,MAM5D,QAAQ,iBAAiB,CAAC,CAAC,CAAC,KAAG,UA6DxC,CAAC"}

package/dist/src/styles/utils/styleVarianceAuthority.js

@@ -1,97 +0,0 @@
-/**
- * Style Variance Authority - like CVA but for React Native styles
- *
- * @example
- * const buttonStyles = sva({
- *   base: { padding: 16, borderRadius: 8 },
- *   variants: {
- *     size: {
- *       sm: { padding: 8 },
- *       lg: { padding: 24 },
- *     },
- *     intent: {
- *       primary: { backgroundColor: 'blue' },
- *       danger: { backgroundColor: 'red' },
- *     },
- *   },
- *   compoundVariants: [
- *     { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
- *   ],
- *   defaultVariants: {
- *     size: 'sm',
- *     intent: 'primary',
- *   },
- * });
- *
- * const style = buttonStyles({ size: 'lg' });
- */
-/**
- * Filters out undefined values from props to prevent them from overriding defaults
- */
-const filterUndefinedProps = (props) => {
-    if (!props)
-        return undefined;
-    const result = {};
-    const keys = Object.keys(props);
-    for (let i = 0; i < keys.length; i++) {
-        const key = keys[i];
-        if (props[key] !== undefined) {
-            result[key] = props[key];
-        }
-    }
-    return Object.keys(result).length > 0 ? result : undefined;
-};
-export const sva = (config) => {
-    const { base, variants, compoundVariants, defaultVariants } = config;
-    // Cache variant keys once - they never change
-    const variantKeys = variants ? Object.keys(variants) : [];
-    return (props) => {
-        // Start with base or empty object
-        const result = base ? { ...base } : {};
-        // No variants defined - return base
-        if (!variants) {
-            return result;
-        }
-        // Filter out undefined props to prevent them from overriding defaults
-        const filteredProps = filterUndefinedProps(props);
-        // Merge props with defaults
-        const mergedProps = defaultVariants
-            ? { ...defaultVariants, ...filteredProps }
-            : filteredProps;
-        // Apply variant styles
-        if (mergedProps) {
-            for (let i = 0; i < variantKeys.length; i++) {
-                const variantKey = variantKeys[i];
-                const variantValue = mergedProps[variantKey];
-                if (variantValue !== undefined) {
-                    const variantStyle = variants[variantKey]?.[variantValue];
-                    if (variantStyle) {
-                        Object.assign(result, variantStyle);
-                    }
-                }
-            }
-        }
-        // Apply compound variants (early exit if none)
-        if (compoundVariants && compoundVariants.length > 0 && mergedProps) {
-            for (let i = 0; i < compoundVariants.length; i++) {
-                const compound = compoundVariants[i];
-                const { style, ...conditions } = compound;
-                // Check if all conditions match
-                let matches = true;
-                const conditionKeys = Object.keys(conditions);
-                for (let j = 0; j < conditionKeys.length; j++) {
-                    const conditionKey = conditionKeys[j];
-                    if (mergedProps[conditionKey] !==
-                        conditions[conditionKey]) {
-                        matches = false;
-                        break;
-                    }
-                }
-                if (matches) {
-                    Object.assign(result, style);
-                }
-            }
-        }
-        return result;
-    };
-};

package/src/lib/Components/Box/Box.types.ts

@@ -1,3 +0,0 @@
-import { LumenViewStyleProps } from '../../../styles';
-
-export type BoxProps = LumenViewStyleProps;

package/src/lib/Components/Box/index.ts

@@ -1,2 +0,0 @@
-export * from './Box';
-export type { BoxProps } from './Box';

package/src/lib/Components/Text/Text.tsx

@@ -1,35 +0,0 @@
-import { Text as RNText } from 'react-native';
-import { createStyledText, type LumenTextStyleProps } from '../../../styles';
-
-/**
- * Text - A typography component with typo support and token-constrained style props.
- *
- * Text is a wrapper around React Native's Text that accepts a `typo` prop for
- * typography presets, plus design token-based style props for colors, spacing, etc.
- *
- * @see {@link https://ldls.vercel.app/?path=/docs/typography-text--docs Storybook}
- *
- * @example
- * ```tsx
- * import { Text } from '@ledgerhq/lumen-ui-rnative';
- *
- * // Basic usage with typography typo
- * <Text typo='body1'>Hello World</Text>
- *
- * // With custom color
- * <Text typo='heading2SemiBold' color='muted'>
- *   Subtitle
- * </Text>
- *
- * // With spacing
- * <Text typo='body2' marginTop='s8' color='base'>
- *   Description text
- * </Text>
- *
- * // style prop for complete override
- * <Text typo='body1' style={{ letterSpacing: 127 }} />
- * ```
- */
-export const Text = createStyledText(RNText);
-
-export type TextProps = LumenTextStyleProps;

package/src/lib/Components/_ToRemove/ToRemove.tsx

@@ -1,65 +0,0 @@
-import { Text, View } from 'react-native';
-import { LumenStyleSheet } from '../../../styles/LumenStyleSheet';
-import { LumenStyleSheetTheme } from '../../../styles/types';
-
-type Variant = 'primary' | 'secondary' | 'error';
-
-const useToRemoveStyles = (variant: Variant) => {
-  return LumenStyleSheet.useCreate((theme: LumenStyleSheetTheme) => {
-    const bgColorMap: Record<Variant, string> = {
-      primary: theme.colors.bg.accent,
-      secondary: theme.colors.bg.surface,
-      error: theme.colors.bg.error,
-    };
-
-    const textColorMap: Record<Variant, string> = {
-      primary: theme.colors.text.onAccent,
-      secondary: theme.colors.text.base,
-      error: theme.colors.text.error,
-    };
-
-    return {
-      container: {
-        backgroundColor: bgColorMap[variant],
-        padding: theme.spacings.s16,
-        borderRadius: theme.borderRadius.md,
-        gap: theme.spacings.s8,
-        boxShadow: theme.shadows.xl,
-        shadowColor: theme.colors.border.error,
-        elevation: 4,
-        width: 200,
-        minHeight: 80,
-      },
-      title: {
-        color: textColorMap[variant],
-        ...theme.typographies.body1SemiBold,
-      },
-      description: {
-        color: textColorMap[variant],
-        ...theme.typographies.body2,
-        opacity: 0.8,
-      },
-    };
-  });
-};
-
-type ToRemoveProps = {
-  variant?: Variant;
-  title?: string;
-  description?: string;
-};
-
-export const ToRemove = ({
-  variant = 'primary',
-  title = 'Card Title',
-  description = 'Description text',
-}: ToRemoveProps) => {
-  const styles = useToRemoveStyles(variant);
-
-  return (
-    <View style={styles.container}>
-      <Text style={styles.title}>{title}</Text>
-      <Text style={styles.description}>{description}</Text>
-    </View>
-  );
-};

package/src/styles/utils/styleVarianceAuthority.test.ts

@@ -1,302 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { sva, VariantProps } from './styleVarianceAuthority';
-
-describe('sva', () => {
-  describe('base styles', () => {
-    it('should return base styles when no variants', () => {
-      const styles = sva({
-        base: { padding: 16, borderRadius: 8 },
-      });
-
-      expect(styles()).toEqual({ padding: 16, borderRadius: 8 });
-    });
-
-    it('should return empty object when no config', () => {
-      const styles = sva({});
-
-      expect(styles()).toEqual({});
-    });
-  });
-
-  describe('variants', () => {
-    it('should apply single variant', () => {
-      const styles = sva({
-        base: { padding: 16 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-        },
-      });
-
-      expect(styles({ size: 'sm' })).toEqual({ padding: 8 });
-      expect(styles({ size: 'lg' })).toEqual({ padding: 24 });
-    });
-
-    it('should apply multiple variants', () => {
-      const styles = sva({
-        base: { padding: 16 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-      });
-
-      expect(styles({ size: 'lg', intent: 'danger' })).toEqual({
-        padding: 24,
-        backgroundColor: 'red',
-      });
-    });
-
-    it('should merge base with variants', () => {
-      const styles = sva({
-        base: { borderRadius: 8, opacity: 1 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-          },
-        },
-      });
-
-      expect(styles({ size: 'sm' })).toEqual({
-        borderRadius: 8,
-        opacity: 1,
-        padding: 8,
-      });
-    });
-  });
-
-  describe('defaultVariants', () => {
-    it('should apply default variants when no props provided', () => {
-      const styles = sva({
-        base: { borderRadius: 8 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-        },
-        defaultVariants: {
-          size: 'sm',
-        },
-      });
-
-      expect(styles()).toEqual({ borderRadius: 8, padding: 8 });
-    });
-
-    it('should override defaults with provided props', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-        },
-        defaultVariants: {
-          size: 'sm',
-        },
-      });
-
-      expect(styles({ size: 'lg' })).toEqual({ padding: 24 });
-    });
-
-    it('should not let explicit undefined override defaults', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-        defaultVariants: {
-          size: 'sm',
-          intent: 'primary',
-        },
-      });
-
-      // Explicit undefined should fall back to defaults
-      expect(styles({ size: undefined })).toEqual({
-        padding: 8,
-        backgroundColor: 'blue',
-      });
-      expect(styles({ size: undefined, intent: undefined })).toEqual({
-        padding: 8,
-        backgroundColor: 'blue',
-      });
-      // Partial override with explicit undefined on other
-      expect(styles({ size: 'lg', intent: undefined })).toEqual({
-        padding: 24,
-        backgroundColor: 'blue',
-      });
-    });
-  });
-
-  describe('compoundVariants', () => {
-    it('should apply compound variant when conditions match', () => {
-      const styles = sva({
-        base: { padding: 16 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-        compoundVariants: [
-          { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
-        ],
-      });
-
-      expect(styles({ size: 'lg', intent: 'danger' })).toEqual({
-        padding: 24,
-        backgroundColor: 'red',
-        borderWidth: 2,
-      });
-    });
-
-    it('should not apply compound variant when conditions do not match', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-        compoundVariants: [
-          { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
-        ],
-      });
-
-      expect(styles({ size: 'lg', intent: 'primary' })).toEqual({
-        padding: 24,
-        backgroundColor: 'blue',
-      });
-    });
-
-    it('should apply multiple compound variants', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: {},
-            lg: {},
-          },
-          intent: {
-            primary: {},
-            danger: {},
-          },
-        },
-        compoundVariants: [
-          { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
-          { size: 'lg', intent: 'primary', style: { borderWidth: 1 } },
-        ],
-      });
-
-      expect(styles({ size: 'lg', intent: 'danger' })).toEqual({
-        borderWidth: 2,
-      });
-      expect(styles({ size: 'lg', intent: 'primary' })).toEqual({
-        borderWidth: 1,
-      });
-    });
-
-    it('should apply compound variants with default variants only', () => {
-      const styles = sva({
-        base: { borderRadius: 8 },
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-        defaultVariants: {
-          size: 'lg',
-          intent: 'danger',
-        },
-        compoundVariants: [
-          { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
-        ],
-      });
-
-      // Calling without props should use defaults and trigger compound variant
-      expect(styles()).toEqual({
-        borderRadius: 8,
-        padding: 24,
-        backgroundColor: 'red',
-        borderWidth: 2,
-      });
-    });
-
-    it('should apply compound variants when defaults are partially overridden', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-            danger: { backgroundColor: 'red' },
-          },
-        },
-        defaultVariants: {
-          size: 'sm',
-          intent: 'danger',
-        },
-        compoundVariants: [
-          { size: 'lg', intent: 'danger', style: { borderWidth: 2 } },
-        ],
-      });
-
-      // Override size to lg, intent stays at default danger -> compound should match
-      expect(styles({ size: 'lg' })).toEqual({
-        padding: 24,
-        backgroundColor: 'red',
-        borderWidth: 2,
-      });
-    });
-  });
-
-  describe('VariantProps type', () => {
-    it('should infer variant props type', () => {
-      const styles = sva({
-        variants: {
-          size: {
-            sm: { padding: 8 },
-            lg: { padding: 24 },
-          },
-          intent: {
-            primary: { backgroundColor: 'blue' },
-          },
-        },
-      });
-
-      // Type test - this should compile without errors
-      type Props = VariantProps<typeof styles>;
-      const props: Props = { size: 'sm', intent: 'primary' };
-
-      expect(styles(props)).toEqual({ padding: 8, backgroundColor: 'blue' });
-    });
-  });
-});