@ledgerhq/lumen-ui-rnative 0.0.44 → 0.0.46

package/src/styles/resolveStyle/resolveStyle.ts

@@ -1,112 +0,0 @@
-import { getObjectPath } from '@ledgerhq/lumen-utils-shared';
-import type { ViewStyle, TextStyle, ViewProps, TextProps } from 'react-native';
-import type {
-  LumenStyleSheetTheme,
-  LumenTextStyleProps,
-  LumenViewStyleProps,
-} from '../types';
-import {
-  VIEW_PROP_CONFIG,
-  TEXT_PROP_CONFIG,
-  LUMEN_VIEW_STYLE_PROPS,
-  LUMEN_TEXT_STYLE_PROPS,
-} from './resolveConfig';
-
-/**
- * Unified style resolver
- * Config-driven: single loop resolves all props via provided config
- */
-const resolveStyle = <T extends ViewStyle | TextStyle>(
-  theme: LumenStyleSheetTheme,
-  lumenStyle: LumenViewStyleProps | LumenTextStyleProps,
-  config: typeof VIEW_PROP_CONFIG | typeof TEXT_PROP_CONFIG,
-): T => {
-  const resolved: Record<string, unknown> = {};
-
-  for (const [prop, value] of Object.entries(lumenStyle)) {
-    const propConfig = config[prop as keyof typeof config];
-    if (!propConfig) continue;
-
-    // Passthrough (no path)
-    if (!propConfig.path) {
-      resolved[prop] = value;
-      continue;
-    }
-
-    // Token lookup
-    const resolvedValue = getObjectPath(theme, [
-      ...propConfig.path,
-      value as string,
-    ]);
-
-    // Spread props (like typo) merge into resolved styles
-    if (propConfig.spread && resolvedValue) {
-      Object.assign(resolved, resolvedValue);
-    } else {
-      resolved[prop] = resolvedValue;
-    }
-  }
-
-  return resolved as T;
-};
-
-/**
- * Resolve LumenViewStyleProps to React Native ViewStyle
- */
-export const resolveViewStyle = (
-  theme: LumenStyleSheetTheme,
-  lumenStyle: LumenViewStyleProps,
-): ViewStyle => resolveStyle<ViewStyle>(theme, lumenStyle, VIEW_PROP_CONFIG);
-
-/**
- * Resolve LumenTextStyleProps to React Native TextStyle
- */
-export const resolveTextStyle = (
-  theme: LumenStyleSheetTheme,
-  lumenStyle: LumenTextStyleProps,
-): TextStyle => resolveStyle<TextStyle>(theme, lumenStyle, TEXT_PROP_CONFIG);
-
-/**
- * Unified style props extractor
- * Loops only through input props with O(1) Set lookup
- */
-const extractStyleProps = <
-  StyleProps,
-  RestProps,
-  ReturnType = {
-    lumenStyle: StyleProps;
-    rest: RestProps;
-  },
->(
-  props: Record<string, unknown>,
-  stylePropsSet: Set<string>,
-): ReturnType => {
-  const lumenStyle: Record<string, unknown> = {};
-  const rest: Record<string, unknown> = {};
-
-  for (const key of Object.keys(props)) {
-    if (stylePropsSet.has(key)) {
-      lumenStyle[key] = props[key];
-    } else {
-      rest[key] = props[key];
-    }
-  }
-
-  return { lumenStyle, rest } as ReturnType;
-};
-
-/**
- * Extract styled view props from component props
- */
-export const extractLumenViewStyleProps = (
-  props: LumenViewStyleProps,
-): { lumenStyle: LumenViewStyleProps; rest: ViewProps } =>
-  extractStyleProps(props as Record<string, unknown>, LUMEN_VIEW_STYLE_PROPS);
-
-/**
- * Extract styled text props from component props
- */
-export const extractLumenTextStyleProps = (
-  props: LumenTextStyleProps,
-): { lumenStyle: LumenTextStyleProps; rest: TextProps } =>
-  extractStyleProps(props as Record<string, unknown>, LUMEN_TEXT_STYLE_PROPS);

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' });
-    });
-  });
-});

package/src/styles/utils/styleVarianceAuthority.ts

@@ -1,154 +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];
-};
-
-// Require at least one condition key to prevent empty compound variants that always match
-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;
-
-/**
- * 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 = <T extends Record<string, unknown>>(
-  props: T | undefined,
-): Partial<T> | undefined => {
-  if (!props) return undefined;
-
-  const result: Partial<T> = {};
-  const keys = Object.keys(props) as (keyof T)[];
-
-  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 = <V extends VariantsConfig>(config: VariantConfig<V>) => {
-  const { base, variants, compoundVariants, defaultVariants } = config;
-
-  // Cache variant keys once - they never change
-  const variantKeys = variants ? Object.keys(variants) : [];
-
-  return (props?: VariantPropsInput<V>): StyleValue => {
-    // Start with base or empty object
-    const result: StyleValue = 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 as keyof typeof mergedProps];
-        if (variantValue !== undefined) {
-          const variantStyle = variants[variantKey]?.[variantValue as string];
-          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 as keyof typeof mergedProps] !==
-            conditions[conditionKey as keyof typeof conditions]
-          ) {
-            matches = false;
-            break;
-          }
-        }
-
-        if (matches) {
-          Object.assign(result, style);
-        }
-      }
-    }
-
-    return result;
-  };
-};

package/src/types/nativewind-env.d.ts

@@ -1 +0,0 @@
-/// <reference types="nativewind/types" />

package/tailwind.config.ts

@@ -1,13 +0,0 @@
-import { allBrandsPreset } from '@ledgerhq/lumen-design-core';
-import type { Config } from 'tailwindcss';
-
-const config = {
-  content: [
-    './src/**/*.{js,jsx,ts,tsx}',
-    './.storybook/**/*.{js,jsx,ts,tsx}',
-    './src/**/*.stories.{js,jsx,ts,tsx}',
-  ],
-  presets: [require('nativewind/preset'), allBrandsPreset],
-} satisfies Config;
-
-export default config;