kasy-cli 1.2.1

package/templates/firebase/lib/core/states/user_state_notifier.dart

@@ -0,0 +1,321 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart';
+import 'package:kasy_kit/core/config/features.dart';
+import 'package:kasy_kit/core/data/models/subscription.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/data/repositories/user_repository.dart';
+import 'package:kasy_kit/core/initializer/onstart_service.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/environnements.dart';
+import 'package:kasy_kit/features/authentication/repositories/authentication_repository.dart';
+import 'package:kasy_kit/features/notifications/providers/models/device.dart';
+import 'package:kasy_kit/features/notifications/repositories/device_repository.dart';
+import 'package:logger/logger.dart';
+import 'package:purchases_flutter/models/entitlement_info_wrapper.dart';
+import 'package:riverpod_annotation/riverpod_annotation.dart';
+
+part 'user_state_notifier.g.dart';
+
+/// Use this provider to access the user state (legacy name)
+final userStateNotifierProvider = userStateProvider;
+
+/// This enum is used to parameter the list of the authentication mode
+///
+/// Most of apps try to not force user to create an account to access the app
+/// But you may want to force the user to be authenticated to access the app
+enum AuthenticationMode {
+  /// By default the user will be authenticated anonymously
+  /// This means that the user can access your app without login
+  /// He will be able to link his account later to an email or social login
+  anonymous,
+
+  /// The user requires to be authenticated to access the app
+  /// By default the user won't have any identity
+  authRequired,
+}
+
+/// This class is responsible for managing the state of the user over the app.
+/// It will be used to know if the user is connected or not and to get the user
+@Riverpod(keepAlive: true)
+class UserStateNotifier extends _$UserStateNotifier implements OnStartService {
+  Logger get _logger => Logger();
+
+  AuthenticationRepository get _authenticationRepository =>
+      ref.read(authRepositoryProvider);
+
+  DeviceRepository get _deviceRepository => ref.read(deviceRepositoryProvider);
+
+  UserRepository get _userRepository => ref.read(userRepositoryProvider);
+
+  /// The authentication mode of the app.
+  /// On web (when withWeb is true), always require explicit auth —
+  /// anonymous accounts are not used on web.
+  /// see [AuthenticationMode]
+  AuthenticationMode get mode {
+    if (kIsWeb && withWeb) return AuthenticationMode.authRequired;
+    return ref.read(environmentProvider).authenticationMode;
+  }
+
+  @override
+  UserState build() {
+    return const UserState(user: User.loading());
+  }
+
+  @override
+  Future<void> init() async {
+    try {
+      await _loadState();
+    } catch (e, stacktrace) {
+      _logger.e(e, stackTrace: stacktrace);
+      if (kDebugMode) {
+        // we automatically logout the user if an error occurs in debug mode
+        // customize this behavior to fit your needs
+        _authenticationRepository.logout();
+      }
+      rethrow;
+    }
+    assert(state.user is! LoadingUserData, 'UserStateNotifier is not ready');
+    await _initDeviceRegistration();
+    _deviceRepository.onTokenUpdate(_onUpdateToken);
+  }
+
+  /// This function is called when the user click on the signin button
+  /// It will load the user state and register the device to the notification service
+  /// It will also load the subscription state
+  Future<void> onSignin() async {
+    state = const UserState(user: User.loading());
+    await _loadState();
+    await _initDeviceRegistration();
+  }
+
+  /// Set the user as onboarded in the database
+  /// This function is called when the user has completed the onboarding
+  Future<void> onOnboarded() async {
+    if (state.user.idOrNull == null) {
+      // Guest with no account: persist onboarding in local state only.
+      // No Firestore document exists yet — no write needed.
+      state = state.copyWith(user: const User.anonymous(onboarded: true));
+      return;
+    }
+    final newUser = await _userRepository.setOnboarded(state.user);
+    state = state.copyWith(user: newUser);
+  }
+
+  /// Mark the user as onboarded immediately (optimistic) and write to the
+  /// backend in background. Used by the skip-onboarding flow so navigation
+  /// to home is instant — no spinner while waiting for a network round-trip.
+  void onSkippedOnboarding() {
+    state = state.copyWith(
+      user: switch (state.user) {
+        final AuthenticatedUserData u => u.copyWith(onboarded: true),
+        final AnonymousUserData u => u.copyWith(onboarded: true),
+        final LoadingUserData _ => const User.anonymous(onboarded: true),
+      },
+    );
+    final id = state.user.idOrNull;
+    if (id != null) {
+      unawaited(_userRepository.setOnboarded(state.user));
+    }
+  }
+
+  /// This function is called when the user click on the logout button
+  /// It will unregister the device from the notification service
+  /// and logout the user
+  Future<void> onLogout() async {
+    final userId = state.user.idOrThrow;
+    _deviceRepository.removeTokenUpdateListener();
+    await _deviceRepository.unregister(userId);
+    await _authenticationRepository.logout();
+    state = const UserState(user: User.anonymous());
+    if (mode == AuthenticationMode.anonymous) {
+      await _loadAnonymousState();
+    }
+  }
+
+  /// Refresh the user
+  Future<void> onUpdateAvatar() async {
+    await refresh();
+  }
+
+  /// Refresh the user
+  Future<void> refresh() async {
+    final id = state.user.idOrNull;
+    if (id == null) return; // Guest: no Firestore document, nothing to refresh
+    final user = await _userRepository.get(id);
+    // Preserve the id if the Firestore document is not found (e.g. backend not
+    // yet deployed), so the user never loses their session identity.
+    state = state.copyWith(user: user ?? User.anonymous(id: id));
+  }
+
+  /// This function is called after a user successfuly purchased a subscription
+  /// It will refresh the subscription state without waiting for the webhook
+  /// (which can take some time and could show a wrong state to the user)
+  /// On next app start, the subscription will be refreshed from the webhook result
+  Future<void> refreshSubscription({
+    SubscriptionProduct? product,
+    List<EntitlementInfo>? entitlements,
+  }) async {
+    if (product != null) {
+      final newUser = switch (state.user) {
+        final AuthenticatedUserData user => user.copyWith(
+          subscription: Subscription.active(
+            activeOffer: product,
+            entitlements: entitlements,
+          ),
+        ),
+        final AnonymousUserData user => user.copyWith(
+          subscription: Subscription.active(
+            activeOffer: product,
+            entitlements: entitlements,
+          ),
+        ),
+        final LoadingUserData _ => throw 'User is not connected',
+      };
+      state = state.copyWith(user: newUser);
+      return;
+    }
+    await Future.delayed(const Duration(seconds: 2));
+    await _loadState();
+  }
+
+  /// Apple store and Google play stores requires you to be able to delete a user account on demand
+  /// Here is the function to do it.
+  /// It will delete the user account and logout the user
+  Future<void> deleteAccount() async {
+    final userId = state.user.idOrThrow;
+    _deviceRepository.removeTokenUpdateListener();
+    try {
+      await _deviceRepository.unregister(userId);
+    } catch (e) {
+      _logger.w('Failed to unregister device during account deletion: $e');
+    }
+    await _userRepository.delete();
+    await _authenticationRepository.logout();
+    state = const UserState(user: User.anonymous());
+
+    if (mode == AuthenticationMode.anonymous) {
+      await _loadAnonymousState();
+    }
+  }
+
+  // -------------------------------
+  // PRIVATES
+  // -------------------------------
+
+  /// load anonymous state for the user
+  Future<void> _loadAnonymousState() async {
+    await _authenticationRepository.signupAnonymously();
+    await Future.delayed(const Duration(seconds: 1));
+    final credentials = await _authenticationRepository.get();
+    var user = await _userRepository.get(credentials!.id);
+    // We retry to get the user 3 times (sometimes the user creation trigger is not fast enough)
+    var retry = 0;
+    while (user == null && retry < 3) {
+      await Future.delayed(const Duration(seconds: 1));
+      user = await _userRepository.get(credentials.id);
+      retry++;
+    }
+    if (user == null) {
+      // Backend not deployed yet: the Cloud Function onUserRegistration has not
+      // created the Firestore document. Log the issue for the developer and fall
+      // back to a local anonymous state so the app still opens.
+      _logger.e(
+        '⚠️  User profile not found in database.\n'
+        '    The backend may not be deployed yet.\n'
+        '    Run: kasy deploy\n'
+        '    Then restart the app.',
+      );
+      state = state.copyWith(user: User.anonymous(id: credentials.id));
+      return;
+    }
+    state = state.copyWith(user: user);
+  }
+
+  /// Load the state of the user
+  Future<void> _loadState() async {
+    final credentials = await _authenticationRepository.get();
+
+    if (credentials == null && mode == AuthenticationMode.anonymous) {
+      _logger.i('Anonymous user mode activated, signup anonymously');
+      await _loadAnonymousState();
+    } else if (credentials == null && mode == AuthenticationMode.authRequired) {
+      _logger.i('Authentification required, user is not connected');
+      state = state.copyWith(user: const User.anonymous());
+    } else if (credentials != null) {
+      _logger.i('User is connected with id ${credentials.id}');
+      var user = await _userRepository.get(credentials.id);
+      // Retry a few times: the Cloud Function onUserRegistration may not have
+      // finished creating the Firestore document yet (race condition on first login).
+      var retry = 0;
+      while (user == null && retry < 3) {
+        await Future.delayed(const Duration(seconds: 1));
+        user = await _userRepository.get(credentials.id);
+        retry++;
+      }
+      if (user == null) {
+        // User document not found after login. Possible causes:
+        // - Firebase: onUserRegistration Cloud Function not deployed or failed
+        // - Supabase: handle_new_user trigger not run yet (race) or failed
+        // - User was deleted but session was still cached
+        // Logout to clear invalid session, then create new anonymous user if applicable.
+        _logger.e(
+          '⚠️  User profile not found in database after sign-in.\n'
+          '    Logging out and creating new anonymous user.',
+        );
+        await _authenticationRepository.logout();
+        state = state.copyWith(user: const User.anonymous());
+        if (mode == AuthenticationMode.anonymous) {
+          await _loadAnonymousState();
+        }
+        return;
+      }
+      // If the Firestore document is anonymous (no email) but Firebase Auth
+      // already has an email (happens after linkWithProvider — Google, email, etc.),
+      // sync the email and name so the user is properly recognised as authenticated.
+      if (user is AnonymousUserData) {
+        final authEmail = await _authenticationRepository.getCurrentUserEmail();
+        if (authEmail != null && authEmail.isNotEmpty) {
+          final authName = await _authenticationRepository
+              .getCurrentUserDisplayName();
+          await _userRepository.updateEmailAndName(
+            userId: credentials.id,
+            email: authEmail,
+            name: authName,
+          );
+          final syncedUser = await _userRepository.get(credentials.id);
+          state = state.copyWith(user: syncedUser ?? user);
+          return;
+        }
+      }
+      state = state.copyWith(user: user);
+    }
+  }
+
+  /// If user has an ID we will register his device to send notifications from
+  /// the server to the device (only if user has accepted them)
+  /// Maybe save your device in UserState if you need it in your app
+  Future<void> _initDeviceRegistration() async {
+    if (kIsWeb) return;
+    final userId = state.user.idOrNull;
+    if (userId == null) {
+      return;
+    }
+    try {
+      final _ = await _deviceRepository.register(userId);
+    } catch (err, stacktrace) {
+      _logger.e(err, stackTrace: stacktrace);
+      _logger.e('''
+          ❌ Your device seems not to be registered.
+          Check that you correctly setup a device registration API
+          see: `lib/features/notifications/api/device_api.dart`
+        ''');
+    }
+  }
+
+  /// This function is called when the device token is updated
+  /// It will update the token in the database
+  Future<void> _onUpdateToken(Device device) async {
+    await _deviceRepository.updateToken(device.token);
+  }
+}

package/templates/firebase/lib/core/theme/colors.dart

@@ -0,0 +1,262 @@
+import 'package:flutter/material.dart';
+
+/// Kasy Design System — Color Tokens
+///
+/// Single source of truth for all colors in the app.
+/// To change a color across the entire app, change it here.
+///
+/// Usage via context extension:
+///   context.colors.primary
+///   context.colors.surfacePrimarySoft / .surfaceNeutralSoft / .surfaceErrorSoft
+///   context.colors.outlineButton
+///   context.colors.success / .muted
+class KasyColors extends ThemeExtension<KasyColors> {
+  /// Vermelho de erro/danger — mesmo tom claro/escuro; vivo e saturado (#FF3B30, estilo sistema).
+  static const Color semanticError = Color(0xFFFF3B30);
+
+  // --- Brand ---
+  final Color primary;
+  final Color onPrimary;
+
+  // --- Backgrounds ---
+  final Color background;
+  final Color onBackground;
+
+  // --- Surfaces ---
+  final Color surface;
+  final Color onSurface;
+
+  /// Filled tint behind primary-accent controls (pill “secondary”: pale blue /
+  /// light; charcoal tint / dark). Foreground stays [primary].
+  final Color surfacePrimarySoft;
+
+  /// Filled neutral tint (“tertiary” row: light grey / light; charcoal / dark).
+  /// Foreground: [onSurface].
+  final Color surfaceNeutralSoft;
+
+  /// Destructive soft fill (“danger soft”: pale rose / light; saturated burgundy
+  /// / dark). Foreground stays [error].
+  final Color surfaceErrorSoft;
+
+  /// Neutral fill for avatar icon/initials fallback and stacked “+N” (theme-aware).
+  final Color avatarFallbackFill;
+
+  // --- Semantic: Error ---
+  final Color error;
+  final Color onError;
+
+  // --- Semantic: Success ---
+  final Color success;
+  final Color onSuccess;
+
+  // --- Semantic: Warning ---
+  final Color warning;
+  final Color onWarning;
+
+  // --- Structural ---
+  /// Default divider / input borders.
+  final Color outline;
+  /// Pills/chips/outline buttons on canvas (readable in dark mode).
+  final Color outlineButton;
+  /// Secondary text / disabled state.
+  final Color muted;
+
+  /// Form field labels ([KasyTextField], [KasyTextArea]): slightly darker than
+  /// [muted] in light mode, slightly lighter in dark mode.
+  Color get fieldLabel {
+    final bool isDark = background.computeLuminance() < 0.5;
+    return Color.lerp(muted, onSurface, isDark ? 0.36 : 0.28)!;
+  }
+
+  // --- Greys (legacy — prefer muted/outline for new code) ---
+  final Color grey1;
+  final Color grey2;
+  final Color grey3;
+
+  // --- Premium (paywall visual identity) ---
+  final Color premiumOverlayMid;   // paywall background gradient — mid tone
+  final Color premiumOverlayDark;  // paywall background gradient — dark tone
+  final Color premiumBannerText;   // text color for the premium banner (PremiumWideBanner)
+
+  const KasyColors({
+    required this.primary,
+    required this.onPrimary,
+    required this.background,
+    required this.onBackground,
+    required this.surface,
+    required this.onSurface,
+    required this.surfacePrimarySoft,
+    required this.surfaceNeutralSoft,
+    required this.surfaceErrorSoft,
+    required this.avatarFallbackFill,
+    required this.error,
+    required this.onError,
+    required this.success,
+    required this.onSuccess,
+    required this.warning,
+    required this.onWarning,
+    required this.outline,
+    required this.outlineButton,
+    required this.muted,
+    required this.grey1,
+    required this.grey2,
+    required this.grey3,
+    required this.premiumOverlayMid,
+    required this.premiumOverlayDark,
+    required this.premiumBannerText,
+  });
+
+  factory KasyColors.light() => const KasyColors(
+        primary: Color(0xFF1E88E5),
+        onPrimary: Color(0xFFFFFFFF),
+        // Canvas: slightly lighter than systemGroupedBackground for a softer wash; surfaces stay white.
+        background: Color(0xFFF7F7F7),
+        onBackground: Color(0xFF000000),
+        surface: Color(0xFFFFFFFF),
+        onSurface: Color(0xFF000000),
+        surfacePrimarySoft: Color(0xFFDFE6F0),
+        surfaceNeutralSoft: Color(0xFFEFEFEF),
+        surfaceErrorSoft: Color(0xFFFFEBEE),
+        avatarFallbackFill: Color(0xFFF2F2F2),
+        error: KasyColors.semanticError,
+        onError: Color(0xFFFFFFFF),
+        success: Color(0xFF34C759),
+        onSuccess: Color(0xFFFFFFFF),
+        warning: Color(0xFFF57F17),
+        onWarning: Color(0xFFFFFFFF),
+        outline: Color(0xFFC6C6C8),
+        outlineButton: Color(0xFFB8BFC9),
+        muted: Color(0xFF7D8488),
+        grey1: Color(0xFFBEC1C3),
+        grey2: Color(0xFF7D8488),
+        grey3: Color(0xFF263238),
+        premiumOverlayMid: Color(0xFF9997A1),
+        premiumOverlayDark: Color(0xFF130F26),
+        premiumBannerText: Color(0xFF49250A),
+      );
+
+  factory KasyColors.dark() => const KasyColors(
+        primary: Color(0xFF1E88E5),
+        onPrimary: Color(0xFFFFFFFF),
+        // Canvas: Material dark baseline; surfaces: iOS-style elevated grey (cards / chrome).
+        background: Color(0xFF060608),
+        onBackground: Color(0xFFFAFAFA),
+        surface: Color(0xFF18181B),
+        onSurface: Color(0xFFFFFFFF),
+        surfacePrimarySoft: Color(0xFF2C323A),
+        surfaceNeutralSoft: Color(0xFF232325),
+        surfaceErrorSoft: Color(0xFF3F2A2D),
+        avatarFallbackFill: Color(0xFF2C2C2E),
+        error: KasyColors.semanticError,
+        onError: Color(0xFFFFFFFF),
+        success: Color(0xFF30D158),
+        onSuccess: Color(0xFFFFFFFF),
+        warning: Color(0xFFFFCA28),
+        onWarning: Color(0xFF000000),
+        outline: Color(0xFF38383A),
+        outlineButton: Color(0x4DFFFFFF),
+        muted: Color(0xFF7D8488),
+        grey1: Color(0xFF263238),
+        grey2: Color(0xFF7D8488),
+        grey3: Color(0xFFBEC1C3),
+        premiumOverlayMid: Color(0xFF9997A1),
+        premiumOverlayDark: Color(0xFF130F26),
+        premiumBannerText: Color(0xFF49250A),
+      );
+
+  @override
+  ThemeExtension<KasyColors> copyWith({
+    Color? primary,
+    Color? onPrimary,
+    Color? background,
+    Color? onBackground,
+    Color? surface,
+    Color? onSurface,
+    Color? surfacePrimarySoft,
+    Color? surfaceNeutralSoft,
+    Color? surfaceErrorSoft,
+    Color? avatarFallbackFill,
+    Color? error,
+    Color? onError,
+    Color? success,
+    Color? onSuccess,
+    Color? warning,
+    Color? onWarning,
+    Color? outline,
+    Color? outlineButton,
+    Color? muted,
+    Color? grey1,
+    Color? grey2,
+    Color? grey3,
+    Color? premiumOverlayMid,
+    Color? premiumOverlayDark,
+    Color? premiumBannerText,
+  }) {
+    return KasyColors(
+      primary: primary ?? this.primary,
+      onPrimary: onPrimary ?? this.onPrimary,
+      background: background ?? this.background,
+      onBackground: onBackground ?? this.onBackground,
+      surface: surface ?? this.surface,
+      onSurface: onSurface ?? this.onSurface,
+      surfacePrimarySoft: surfacePrimarySoft ?? this.surfacePrimarySoft,
+      surfaceNeutralSoft: surfaceNeutralSoft ?? this.surfaceNeutralSoft,
+      surfaceErrorSoft: surfaceErrorSoft ?? this.surfaceErrorSoft,
+      avatarFallbackFill: avatarFallbackFill ?? this.avatarFallbackFill,
+      error: error ?? this.error,
+      onError: onError ?? this.onError,
+      success: success ?? this.success,
+      onSuccess: onSuccess ?? this.onSuccess,
+      warning: warning ?? this.warning,
+      onWarning: onWarning ?? this.onWarning,
+      outline: outline ?? this.outline,
+      outlineButton: outlineButton ?? this.outlineButton,
+      muted: muted ?? this.muted,
+      grey1: grey1 ?? this.grey1,
+      grey2: grey2 ?? this.grey2,
+      grey3: grey3 ?? this.grey3,
+      premiumOverlayMid: premiumOverlayMid ?? this.premiumOverlayMid,
+      premiumOverlayDark: premiumOverlayDark ?? this.premiumOverlayDark,
+      premiumBannerText: premiumBannerText ?? this.premiumBannerText,
+    );
+  }
+
+  @override
+  ThemeExtension<KasyColors> lerp(
+    covariant ThemeExtension<KasyColors>? other,
+    double t,
+  ) {
+    if (other == null || other is! KasyColors) return this;
+
+    return KasyColors(
+      primary: Color.lerp(primary, other.primary, t)!,
+      onPrimary: Color.lerp(onPrimary, other.onPrimary, t)!,
+      background: Color.lerp(background, other.background, t)!,
+      onBackground: Color.lerp(onBackground, other.onBackground, t)!,
+      surface: Color.lerp(surface, other.surface, t)!,
+      onSurface: Color.lerp(onSurface, other.onSurface, t)!,
+      surfacePrimarySoft:
+          Color.lerp(surfacePrimarySoft, other.surfacePrimarySoft, t)!,
+      surfaceNeutralSoft:
+          Color.lerp(surfaceNeutralSoft, other.surfaceNeutralSoft, t)!,
+      surfaceErrorSoft: Color.lerp(surfaceErrorSoft, other.surfaceErrorSoft, t)!,
+      avatarFallbackFill:
+          Color.lerp(avatarFallbackFill, other.avatarFallbackFill, t)!,
+      error: Color.lerp(error, other.error, t)!,
+      onError: Color.lerp(onError, other.onError, t)!,
+      success: Color.lerp(success, other.success, t)!,
+      onSuccess: Color.lerp(onSuccess, other.onSuccess, t)!,
+      warning: Color.lerp(warning, other.warning, t)!,
+      onWarning: Color.lerp(onWarning, other.onWarning, t)!,
+      outline: Color.lerp(outline, other.outline, t)!,
+      outlineButton: Color.lerp(outlineButton, other.outlineButton, t)!,
+      muted: Color.lerp(muted, other.muted, t)!,
+      grey1: Color.lerp(grey1, other.grey1, t)!,
+      grey2: Color.lerp(grey2, other.grey2, t)!,
+      grey3: Color.lerp(grey3, other.grey3, t)!,
+      premiumOverlayMid: Color.lerp(premiumOverlayMid, other.premiumOverlayMid, t)!,
+      premiumOverlayDark: Color.lerp(premiumOverlayDark, other.premiumOverlayDark, t)!,
+      premiumBannerText: Color.lerp(premiumBannerText, other.premiumBannerText, t)!,
+    );
+  }
+}

package/templates/firebase/lib/core/theme/extensions/theme_extension.dart

@@ -0,0 +1,48 @@
+import 'package:flutter/material.dart';
+import 'package:kasy_kit/core/theme/colors.dart';
+import 'package:kasy_kit/core/theme/providers/theme_provider.dart';
+import 'package:kasy_kit/core/theme/texts.dart';
+import 'package:kasy_kit/core/theme/theme_data/theme_data.dart';
+
+/// Convenience extension to access the entire design system from BuildContext.
+///
+/// Usage:
+///   context.colors.primary          → brand color
+///   context.colors.success           → semantic success color
+///   context.colors.muted             → secondary text color
+///   context.colors.fieldLabel        → form field label (text field / text area)
+///   context.textTheme.bodyMedium     → body text style
+///   context.textTheme.titleLarge     → card title style
+///   KasySpacing.md               → 16.0 (spacing token)
+///   KasyRadius.lgBorderRadius    → BorderRadius.circular(16)
+extension KasyThemeExt on BuildContext {
+  /// Access all Kasy color tokens (primary, surface, success, muted, etc.)
+  KasyColors get colors =>
+      Theme.of(this).extension<KasyColors>()!;
+
+  /// Access the full Material 3 text theme (bodyMedium, titleLarge, etc.)
+  TextTheme get textTheme => Theme.of(this).textTheme;
+
+  /// Access all Kasy typography tokens as KasyTextTheme
+  KasyTextTheme get kasyTextTheme =>
+      Theme.of(this).extension<KasyTextTheme>()!;
+
+  /// Raw Flutter ThemeData
+  ThemeData get theme => Theme.of(this);
+
+  /// Current brightness (light / dark)
+  Brightness get brightness => Theme.of(this).brightness;
+
+  /// Whether current theme is dark mode
+  bool get isDark => brightness == Brightness.dark;
+
+  /// Full Kasy theme data
+  KasyThemeData get kitTheme => ThemeProvider.of(this).current.data;
+}
+
+// Note: KasySpacing and KasyRadius are used directly as static classes.
+// No need to access through context since they are not theme-dependent.
+//
+// Examples:
+//   padding: EdgeInsets.all(KasySpacing.md)
+//   borderRadius: KasyRadius.smBorderRadius