@marioschmidt/design-system-tokens 1.3.7 → 1.3.8

package/dist/android/compose/shared/DesignSystemTheme.kt

@@ -1,520 +0,0 @@
-/**
- * Do not edit directly, this file was auto-generated.
- *
- * BILD Design System Tokens v1.3.7
- * Generated by Style Dictionary v4.2.0
- *
- * Context: Central Design System Theme Provider (Dual-Axis Architecture)
-Unified entry point with separate ColorBrand and ContentBrand axes
- *
- * Copyright (c) 2026 Axel Springer Deutschland GmbH
- * Proprietary and confidential. All rights reserved.
- *
- * Documentation: https://github.com/UXWizard25/vv-token-test-v3/blob/main/packages/tokens/docs/android.md
- */
-
-package com.bild.designsystem.shared
-
-import androidx.compose.foundation.isSystemInDarkTheme
-import androidx.compose.runtime.Composable
-import androidx.compose.runtime.CompositionLocalProvider
-import androidx.compose.runtime.ReadOnlyComposable
-import androidx.compose.runtime.staticCompositionLocalOf
-
-// Color imports (ColorBrand axis)
-import com.bild.designsystem.bild.semantic.BildLightColors
-import com.bild.designsystem.bild.semantic.BildDarkColors
-import com.bild.designsystem.sportbild.semantic.SportbildLightColors
-import com.bild.designsystem.sportbild.semantic.SportbildDarkColors
-
-// Sizing imports (ContentBrand axis)
-import com.bild.designsystem.bild.semantic.BildSizingCompact
-import com.bild.designsystem.bild.semantic.BildSizingMedium
-import com.bild.designsystem.bild.semantic.BildSizingExpanded
-import com.bild.designsystem.sportbild.semantic.SportbildSizingCompact
-import com.bild.designsystem.sportbild.semantic.SportbildSizingMedium
-import com.bild.designsystem.sportbild.semantic.SportbildSizingExpanded
-import com.bild.designsystem.advertorial.semantic.AdvertorialSizingCompact
-import com.bild.designsystem.advertorial.semantic.AdvertorialSizingMedium
-import com.bild.designsystem.advertorial.semantic.AdvertorialSizingExpanded
-
-// Typography imports (ContentBrand axis)
-import com.bild.designsystem.bild.semantic.BildTypographyCompact
-import com.bild.designsystem.bild.semantic.BildTypographyMedium
-import com.bild.designsystem.bild.semantic.BildTypographyExpanded
-import com.bild.designsystem.sportbild.semantic.SportbildTypographyCompact
-import com.bild.designsystem.sportbild.semantic.SportbildTypographyMedium
-import com.bild.designsystem.sportbild.semantic.SportbildTypographyExpanded
-import com.bild.designsystem.advertorial.semantic.AdvertorialTypographyCompact
-import com.bild.designsystem.advertorial.semantic.AdvertorialTypographyMedium
-import com.bild.designsystem.advertorial.semantic.AdvertorialTypographyExpanded
-
-// Density imports (ContentBrand axis)
-// Density is brand-independent (same values across all brands)
-import com.bild.designsystem.shared.DensityDefault
-import com.bild.designsystem.shared.DensityDense
-import com.bild.designsystem.shared.DensitySpacious
-
-// ══════════════════════════════════════════════════════════════════════════════
-// COMPOSITION LOCALS
-// ══════════════════════════════════════════════════════════════════════════════
-
-/**
- * CompositionLocal for current color scheme
- * Type: DesignColorScheme (unified interface)
- */
-internal val LocalDesignColors = staticCompositionLocalOf<DesignColorScheme> { BildLightColors }
-
-/**
- * CompositionLocal for current sizing scheme
- * Type: DesignSizingScheme (unified interface)
- */
-internal val LocalDesignSizing = staticCompositionLocalOf<DesignSizingScheme> { BildSizingCompact }
-
-/**
- * CompositionLocal for current typography scheme
- * Type: DesignTypographyScheme (unified interface)
- */
-internal val LocalDesignTypography = staticCompositionLocalOf<DesignTypographyScheme> { BildTypographyCompact }
-
-/**
- * CompositionLocal for current effects scheme
- * Type: DesignEffectsScheme (unified interface)
- * Note: Effects are brand-independent, only depend on light/dark mode
- */
-internal val LocalDesignEffects = staticCompositionLocalOf<DesignEffectsScheme> { EffectsLight }
-
-/**
- * CompositionLocal for current window size class
- */
-internal val LocalWindowSizeClass = staticCompositionLocalOf { WindowSizeClass.Compact }
-
-/**
- * CompositionLocal for current density
- */
-internal val LocalDensity = staticCompositionLocalOf { Density.Default }
-
-/**
- * CompositionLocal for current density spacing scheme
- * Type: DesignDensityScheme (unified interface)
- */
-internal val LocalDesignDensitySpacing = staticCompositionLocalOf<DesignDensityScheme> { DensityDefault }
-
-/**
- * CompositionLocal for dark theme state
- */
-internal val LocalIsDarkTheme = staticCompositionLocalOf { false }
-
-/**
- * CompositionLocal for current color brand
- */
-internal val LocalColorBrand = staticCompositionLocalOf { ColorBrand.Bild }
-
-/**
- * CompositionLocal for current content brand
- */
-internal val LocalContentBrand = staticCompositionLocalOf { ContentBrand.Bild }
-
-// ══════════════════════════════════════════════════════════════════════════════
-// THEME PROVIDER
-// ══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Central Design System Theme Provider (Dual-Axis Architecture)
- *
- * Provides a unified entry point with two independent brand axes:
- * - ColorBrand: Determines color palette (BILD or SportBILD)
- * - ContentBrand: Determines sizing/typography (BILD, SportBILD, or Advertorial)
- *
- * This enables use cases like "Advertorial content with SportBILD colors".
- *
- * @param colorBrand Color palette to use (BILD or SportBILD)
- * @param contentBrand Content/sizing tokens to use (BILD, SportBILD, or Advertorial)
- * @param darkTheme Whether to use dark color scheme
- * @param sizeClass Window size class for responsive sizing
- * @param density UI density for spacing adjustments
- * @param content Composable content to wrap
- *
- * Usage:
- * ```kotlin
- * // Standard BILD app
- * DesignSystemTheme(
- *     colorBrand = ColorBrand.Bild,
- *     contentBrand = ContentBrand.Bild
- * ) {
- *     MyApp()
- * }
- *
- * // Advertorial with SportBILD colors
- * DesignSystemTheme(
- *     colorBrand = ColorBrand.Sportbild,
- *     contentBrand = ContentBrand.Advertorial
- * ) {
- *     AdvertorialContent()
- * }
- * ```
- */
-@Composable
-fun DesignSystemTheme(
-    colorBrand: ColorBrand = ColorBrand.Bild,
-    contentBrand: ContentBrand = ContentBrand.Bild,
-    darkTheme: Boolean = isSystemInDarkTheme(),
-    sizeClass: WindowSizeClass = WindowSizeClass.Compact,
-    density: Density = Density.Default,
-    content: @Composable () -> Unit
-) {
-    val colors: DesignColorScheme = when (colorBrand) {
-        ColorBrand.Bild -> if (darkTheme) BildDarkColors else BildLightColors
-        ColorBrand.Sportbild -> if (darkTheme) SportbildDarkColors else SportbildLightColors
-    }
-
-    val sizing: DesignSizingScheme = when (contentBrand) {
-        ContentBrand.Bild -> when (sizeClass) {
-            WindowSizeClass.Compact -> BildSizingCompact
-            WindowSizeClass.Medium -> BildSizingMedium
-            WindowSizeClass.Expanded -> BildSizingExpanded
-        }
-        ContentBrand.Sportbild -> when (sizeClass) {
-            WindowSizeClass.Compact -> SportbildSizingCompact
-            WindowSizeClass.Medium -> SportbildSizingMedium
-            WindowSizeClass.Expanded -> SportbildSizingExpanded
-        }
-        ContentBrand.Advertorial -> when (sizeClass) {
-            WindowSizeClass.Compact -> AdvertorialSizingCompact
-            WindowSizeClass.Medium -> AdvertorialSizingMedium
-            WindowSizeClass.Expanded -> AdvertorialSizingExpanded
-        }
-    }
-
-    val typography: DesignTypographyScheme = when (contentBrand) {
-        ContentBrand.Bild -> when (sizeClass) {
-            WindowSizeClass.Compact -> BildTypographyCompact
-            WindowSizeClass.Medium -> BildTypographyMedium
-            WindowSizeClass.Expanded -> BildTypographyExpanded
-        }
-        ContentBrand.Sportbild -> when (sizeClass) {
-            WindowSizeClass.Compact -> SportbildTypographyCompact
-            WindowSizeClass.Medium -> SportbildTypographyMedium
-            WindowSizeClass.Expanded -> SportbildTypographyExpanded
-        }
-        ContentBrand.Advertorial -> when (sizeClass) {
-            WindowSizeClass.Compact -> AdvertorialTypographyCompact
-            WindowSizeClass.Medium -> AdvertorialTypographyMedium
-            WindowSizeClass.Expanded -> AdvertorialTypographyExpanded
-        }
-    }
-
-    // Effects are brand-independent, only depend on light/dark mode
-    val effects: DesignEffectsScheme = if (darkTheme) EffectsDark else EffectsLight
-
-    // Density spacing is brand-independent (like Effects), only depends on density mode
-    val densitySpacing: DesignDensityScheme = when (density) {
-        Density.Default -> DensityDefault
-        Density.Dense -> DensityDense
-        Density.Spacious -> DensitySpacious
-    }
-
-    CompositionLocalProvider(
-        LocalDesignColors provides colors,
-        LocalDesignSizing provides sizing,
-        LocalDesignTypography provides typography,
-        LocalDesignEffects provides effects,
-        LocalDesignDensitySpacing provides densitySpacing,
-        LocalWindowSizeClass provides sizeClass,
-        LocalDensity provides density,
-        LocalIsDarkTheme provides darkTheme,
-        LocalColorBrand provides colorBrand,
-        LocalContentBrand provides contentBrand,
-        content = content
-    )
-}
-
-// ══════════════════════════════════════════════════════════════════════════════
-// THEME ACCESSOR OBJECT
-// ══════════════════════════════════════════════════════════════════════════════
-
-/**
- * Accessor object for Design System theme values
- *
- * Provides convenient access to current theme values from any composable.
- *
- * Usage:
- * ```kotlin
- * @Composable
- * fun MyButton() {
- *     Button(
- *         colors = ButtonDefaults.buttonColors(
- *             containerColor = DesignSystemTheme.colors.coreColorPrimary
- *         )
- *     ) {
- *         Text(
- *             text = "Click me",
- *             fontSize = DesignSystemTheme.sizing.headline1FontSize
- *         )
- *     }
- * }
- * ```
- */
-object DesignSystemTheme {
-
-    /**
-     * Current color scheme (based on ColorBrand and dark/light mode)
-     */
-    val colors: DesignColorScheme
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDesignColors.current
-
-    /**
-     * Current sizing scheme (based on ContentBrand and WindowSizeClass)
-     */
-    val sizing: DesignSizingScheme
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDesignSizing.current
-
-    /**
-     * Current typography scheme (based on ContentBrand and WindowSizeClass)
-     * Use .toComposeTextStyle() on individual styles for Text composable
-     */
-    val typography: DesignTypographyScheme
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDesignTypography.current
-
-    /**
-     * Current effects scheme (shadows, brand-independent)
-     * Use .toModifier() on shadow styles to apply them
-     */
-    val effects: DesignEffectsScheme
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDesignEffects.current
-
-    /**
-     * Internal density spacing scheme - not for direct consumption.
-     * Use the resolver properties below (stackSpaceRespMd, stackSpaceConstLg, etc.)
-     * which automatically resolve based on WindowSizeClass and DensityMode.
-     */
-    internal val densitySpacing: DesignDensityScheme
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDesignDensitySpacing.current
-
-    // ══════════════════════════════════════════════════════════════════════════════
-    // DENSITY-AWARE SPACING (Auto-generated from Breakpoint × Density Matrix)
-    // ══════════════════════════════════════════════════════════════════════════════
-    //
-    // Values resolved at build-time using ID-based cross-collection resolution.
-    // WindowSizeClass mapping: Compact→sm, Medium→md, Expanded→lg
-    //
-    // Consumer API: DesignSystemTheme.stackSpaceRespMd
-
-    // Constant spacing tokens (same value across all breakpoints)
-
-    /** stackSpaceConstSm - constant spacing, varies only by density mode */
-    val stackSpaceConstSm: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 6.dp
-            Density.Default -> 8.dp
-            Density.Spacious -> 10.dp
-        }
-
-    /** stackSpaceConstMd - constant spacing, varies only by density mode */
-    val stackSpaceConstMd: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 8.dp
-            Density.Default -> 12.dp
-            Density.Spacious -> 14.dp
-        }
-
-    /** stackSpaceConstLg - constant spacing, varies only by density mode */
-    val stackSpaceConstLg: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 12.dp
-            Density.Default -> 16.dp
-            Density.Spacious -> 20.dp
-        }
-
-    /** stackSpaceConst2Xl - constant spacing, varies only by density mode */
-    val stackSpaceConst2Xl: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 24.dp
-            Density.Default -> 32.dp
-            Density.Spacious -> 40.dp
-        }
-
-    /** stackSpaceConstXl - constant spacing, varies only by density mode */
-    val stackSpaceConstXl: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 16.dp
-            Density.Default -> 24.dp
-            Density.Spacious -> 28.dp
-        }
-
-    /** stackSpaceConstXs - constant spacing, varies only by density mode */
-    val stackSpaceConstXs: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 2.dp
-            Density.Default -> 6.dp
-            Density.Spacious -> 8.dp
-        }
-
-    /** stackSpaceConst3Xs - constant spacing, varies only by density mode */
-    val stackSpaceConst3Xs: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 2.dp
-            Density.Default -> 2.dp
-            Density.Spacious -> 2.dp
-        }
-
-    /** stackSpaceConst2Xs - constant spacing, varies only by density mode */
-    val stackSpaceConst2Xs: Dp
-        @Composable @ReadOnlyComposable get() = when (density) {
-            Density.Dense -> 2.dp
-            Density.Default -> 4.dp
-            Density.Spacious -> 4.dp
-        }
-
-    // Responsive spacing tokens (resolved by WindowSizeClass × Density)
-
-    /** stackSpaceRespMd - responsive spacing, varies by WindowSizeClass and density mode */
-    val stackSpaceRespMd: Dp
-        @Composable @ReadOnlyComposable get() = when (sizeClass) {
-            WindowSizeClass.Compact -> when (density) {
-                Density.Dense -> 8.dp
-                Density.Default -> 12.dp
-                Density.Spacious -> 14.dp
-            }
-            WindowSizeClass.Medium -> when (density) {
-                Density.Dense -> 12.dp
-                Density.Default -> 16.dp
-                Density.Spacious -> 20.dp
-            }
-            WindowSizeClass.Expanded -> when (density) {
-                Density.Dense -> 16.dp
-                Density.Default -> 24.dp
-                Density.Spacious -> 28.dp
-            }
-        }
-
-    /** stackSpaceRespLg - responsive spacing, varies by WindowSizeClass and density mode */
-    val stackSpaceRespLg: Dp
-        @Composable @ReadOnlyComposable get() = when (sizeClass) {
-            WindowSizeClass.Compact -> when (density) {
-                Density.Dense -> 12.dp
-                Density.Default -> 16.dp
-                Density.Spacious -> 20.dp
-            }
-            WindowSizeClass.Medium -> when (density) {
-                Density.Dense -> 16.dp
-                Density.Default -> 24.dp
-                Density.Spacious -> 28.dp
-            }
-            WindowSizeClass.Expanded -> when (density) {
-                Density.Dense -> 24.dp
-                Density.Default -> 32.dp
-                Density.Spacious -> 40.dp
-            }
-        }
-
-    /** stackSpaceResp2Xl - responsive spacing, varies by WindowSizeClass and density mode */
-    val stackSpaceResp2Xl: Dp
-        @Composable @ReadOnlyComposable get() = when (sizeClass) {
-            WindowSizeClass.Compact -> when (density) {
-                Density.Dense -> 24.dp
-                Density.Default -> 32.dp
-                Density.Spacious -> 40.dp
-            }
-            WindowSizeClass.Medium -> when (density) {
-                Density.Dense -> 24.dp
-                Density.Default -> 32.dp
-                Density.Spacious -> 40.dp
-            }
-            WindowSizeClass.Expanded -> when (density) {
-                Density.Dense -> 48.dp
-                Density.Default -> 64.dp
-                Density.Spacious -> 80.dp
-            }
-        }
-
-    /** stackSpaceRespSm - responsive spacing, varies by WindowSizeClass and density mode */
-    val stackSpaceRespSm: Dp
-        @Composable @ReadOnlyComposable get() = when (sizeClass) {
-            WindowSizeClass.Compact -> when (density) {
-                Density.Dense -> 6.dp
-                Density.Default -> 8.dp
-                Density.Spacious -> 10.dp
-            }
-            WindowSizeClass.Medium -> when (density) {
-                Density.Dense -> 8.dp
-                Density.Default -> 12.dp
-                Density.Spacious -> 14.dp
-            }
-            WindowSizeClass.Expanded -> when (density) {
-                Density.Dense -> 12.dp
-                Density.Default -> 16.dp
-                Density.Spacious -> 20.dp
-            }
-        }
-
-    /** stackSpaceRespXl - responsive spacing, varies by WindowSizeClass and density mode */
-    val stackSpaceRespXl: Dp
-        @Composable @ReadOnlyComposable get() = when (sizeClass) {
-            WindowSizeClass.Compact -> when (density) {
-                Density.Dense -> 16.dp
-                Density.Default -> 24.dp
-                Density.Spacious -> 28.dp
-            }
-            WindowSizeClass.Medium -> when (density) {
-                Density.Dense -> 24.dp
-                Density.Default -> 32.dp
-                Density.Spacious -> 40.dp
-            }
-            WindowSizeClass.Expanded -> when (density) {
-                Density.Dense -> 28.dp
-                Density.Default -> 40.dp
-                Density.Spacious -> 48.dp
-            }
-        }
-
-    /**
-     * Current window size class
-     */
-    val sizeClass: WindowSizeClass
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalWindowSizeClass.current
-
-    /**
-     * Current UI density
-     */
-    val density: Density
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalDensity.current
-
-    /**
-     * Whether dark theme is currently active
-     */
-    val isDarkTheme: Boolean
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalIsDarkTheme.current
-
-    /**
-     * Current color brand
-     */
-    val colorBrand: ColorBrand
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalColorBrand.current
-
-    /**
-     * Current content brand
-     */
-    val contentBrand: ContentBrand
-        @Composable
-        @ReadOnlyComposable
-        get() = LocalContentBrand.current
-}

package/dist/android/compose/shared/DesignTextStyle.kt

@@ -1,84 +0,0 @@
-/**
- * Do not edit directly, this file was auto-generated.
- *
- * BILD Design System Tokens v1.3.7
- * Generated by Style Dictionary v4.2.0
- *
- * Context: DesignTextStyle - Typography composite token
-Represents a complete text style with all typography properties
- *
- * Copyright (c) 2026 Axel Springer Deutschland GmbH
- * Proprietary and confidential. All rights reserved.
- *
- * Documentation: https://github.com/UXWizard25/vv-token-test-v3/blob/main/packages/tokens/docs/android.md
- */
-
-package com.bild.designsystem.shared
-
-import androidx.compose.runtime.Immutable
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.Font
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.text.style.TextDecoration
-import androidx.compose.ui.unit.TextUnit
-import androidx.compose.ui.unit.sp
-
-/**
- * Text case transformation options
- */
-enum class DesignTextCase {
-    Original,
-    Uppercase,
-    Lowercase,
-    Capitalize
-}
-
-/**
- * Design System TextStyle composite token
- *
- * Contains all typography properties for a complete text style.
- * Use [toComposeTextStyle] to convert to Compose's TextStyle with font resolution.
- *
- * Usage:
- * ```kotlin
- * val style = DesignSystemTheme.typography.headline1
- * Text(
- *     text = "Hello",
- *     style = style.toComposeTextStyle(fontResolver)
- * )
- * ```
- */
-@Immutable
-data class DesignTextStyle(
-    val fontFamily: String,
-    val fontWeight: FontWeight,
-    val fontSize: TextUnit,
-    val lineHeight: TextUnit,
-    val letterSpacing: TextUnit = 0.sp,
-    val textCase: DesignTextCase = DesignTextCase.Original,
-    val textDecoration: TextDecoration = TextDecoration.None
-) {
-    /**
-     * Converts this DesignTextStyle to Compose's TextStyle
-     *
-     * @param fontResolver A function that resolves font family name to FontFamily
-     *                     Example: { name -> FontFamily(Font(R.font.gotham_xnarrow)) }
-     * @return A Compose TextStyle ready for use with Text composable
-     */
-    fun toComposeTextStyle(fontResolver: (String) -> FontFamily = { FontFamily.Default }): TextStyle {
-        return TextStyle(
-            fontFamily = fontResolver(fontFamily),
-            fontWeight = fontWeight,
-            fontSize = fontSize,
-            lineHeight = lineHeight,
-            letterSpacing = letterSpacing,
-            textDecoration = textDecoration
-        )
-    }
-
-    /**
-     * Converts this DesignTextStyle to Compose's TextStyle using default system fonts
-     */
-    fun toComposeTextStyle(): TextStyle = toComposeTextStyle { FontFamily.Default }
-}