kasy-cli 1.2.1

package/templates/firebase/lib/core/widgets/debouncer.dart

@@ -0,0 +1,31 @@
+import 'dart:async';
+import 'dart:ui';
+
+/// A class that helps to debounce a function call.
+/// It will prevent the function to be called multiple times in a short period of time.
+/// It will only call the function once the delay is passed.
+/// ex :
+/// ```dart
+/// final debouncer = Debouncer(delay: const Duration(milliseconds: 500));
+/// debouncer.run(() => repository.update(test));
+/// ```
+/// If that functions is called everytime the user types a letter, it will only be called once the user stops typing for 500ms.
+class Debouncer {
+  final Duration delay;
+  Timer? _timer;
+
+  Debouncer({this.delay = const Duration(milliseconds: 500)});
+
+  void run(VoidCallback action) {
+    _timer?.cancel();
+    _timer = Timer(delay, action);
+  }
+}
+
+/// A shortcut to debounce a function call.
+void debounce({
+  Duration duration = const Duration(milliseconds: 500),
+  required VoidCallback action,
+}) {
+  return Debouncer(delay: duration).run(action);
+}

package/templates/firebase/lib/core/widgets/kasy_hover.dart

@@ -0,0 +1,166 @@
+import 'dart:async';
+
+import 'package:flutter/foundation.dart' show kIsWeb;
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/haptics/haptic_feedback_notifier.dart';
+import 'package:kasy_kit/core/theme/theme.dart';
+
+/// Universal hover/press wrapper — works on any widget shape.
+///
+/// Native: animated background fill on press + haptic (no Material ripple).
+/// The pressed state lasts at least [_kMinPressDuration] so it is visible
+/// even on quick taps.
+///
+/// Web: pointer cursor + subtle background on hover, slightly darker on press.
+///
+/// Contrast with [KasyPressableDepth]: this component uses a background fill
+/// while [KasyPressableDepth] uses a scale animation. Use this one for
+/// surfaces that already have their own shape (list rows, cards, menu items,
+/// custom buttons); use [KasyPressableDepth] when you want a "push-in" feel.
+class KasyHover extends ConsumerStatefulWidget {
+  const KasyHover({
+    super.key,
+    required this.child,
+    required this.onTap,
+    this.padding,
+    this.borderRadius = BorderRadius.zero,
+    this.margin,
+    this.semanticLabel,
+    this.hapticEnabled = true,
+    this.pressColor,
+  });
+
+  final Widget child;
+  final VoidCallback onTap;
+
+  /// Internal padding (rendered inside the feedback overlay area).
+  final EdgeInsetsGeometry? padding;
+
+  /// Corner radius of the feedback overlay. Match the value of the parent
+  /// container so the pressed fill does not bleed outside the rounded shape.
+  final BorderRadius borderRadius;
+
+  /// External spacing (not covered by the feedback overlay).
+  final EdgeInsetsGeometry? margin;
+
+  /// Accessibility label for TalkBack / VoiceOver.
+  final String? semanticLabel;
+
+  /// Haptic on tap (automatically ignored on web).
+  final bool hapticEnabled;
+
+  /// Tint color for the hover/press overlay.
+  ///
+  /// When null, falls back to [ColorScheme.onSurface] — a neutral dark/light
+  /// overlay suited for plain surfaces.
+  ///
+  /// Pass the surface's accent color (e.g. [KasyColors.primary]) when the
+  /// background is already tinted so the feedback stays on-palette and avoids
+  /// a mismatched gray cast (e.g. a primary-tinted button should deepen with
+  /// primary, not darken with neutral gray).
+  final Color? pressColor;
+
+  @override
+  ConsumerState<KasyHover> createState() => _KasyHoverState();
+}
+
+class _KasyHoverState extends ConsumerState<KasyHover> {
+  // Minimum duration the pressed background stays visible — prevents an
+  // imperceptible flash on very quick taps.
+  static const Duration _kMinPressDuration = Duration(milliseconds: 160);
+
+  bool _hovered = false;
+  bool _pressed = false;
+  Timer? _releaseTimer;
+
+  @override
+  void dispose() {
+    _releaseTimer?.cancel();
+    super.dispose();
+  }
+
+  Color _overlayColor(BuildContext context) {
+    final bool isDark = Theme.of(context).brightness == Brightness.dark;
+    final Color base = widget.pressColor ?? context.colors.onSurface;
+    if (_pressed) return base.withValues(alpha: isDark ? 0.04 : 0.10);
+    if (_hovered) return base.withValues(alpha: isDark ? 0.02 : 0.06);
+    return Colors.transparent;
+  }
+
+  void _onTapDown(TapDownDetails _) {
+    _releaseTimer?.cancel();
+    setState(() => _pressed = true);
+  }
+
+  void _onTapUp(TapUpDetails _) {
+    // Release is controlled by the timer in _handleTap so the pressed
+    // state is always visible for at least _kMinPressDuration.
+  }
+
+  void _onTapCancel() {
+    _releaseTimer?.cancel();
+    setState(() => _pressed = false);
+  }
+
+  void _handleTap() {
+    if (widget.hapticEnabled && !kIsWeb && ref.read(hapticFeedbackProvider)) {
+      HapticFeedback.selectionClick();
+    }
+    widget.onTap();
+    _releaseTimer = Timer(_kMinPressDuration, () {
+      if (mounted) setState(() => _pressed = false);
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final Widget content = AnimatedContainer(
+      duration: const Duration(milliseconds: 120),
+      curve: Curves.easeOut,
+      decoration: BoxDecoration(
+        color: _overlayColor(context),
+        borderRadius: widget.borderRadius,
+      ),
+      padding: widget.padding,
+      child: widget.child,
+    );
+
+    Widget interactive = GestureDetector(
+      behavior: HitTestBehavior.opaque,
+      onTap: _handleTap,
+      onTapDown: _onTapDown,
+      onTapUp: _onTapUp,
+      onTapCancel: _onTapCancel,
+      child: content,
+    );
+
+    if (kIsWeb) {
+      interactive = MouseRegion(
+        cursor: SystemMouseCursors.click,
+        onEnter: (_) => setState(() => _hovered = true),
+        onExit: (_) {
+          setState(() {
+            _hovered = false;
+            _pressed = false;
+          });
+        },
+        child: interactive,
+      );
+    }
+
+    if (widget.semanticLabel != null) {
+      interactive = Semantics(
+        button: true,
+        label: widget.semanticLabel,
+        child: interactive,
+      );
+    }
+
+    if (widget.margin != null) {
+      return Padding(padding: widget.margin!, child: interactive);
+    }
+    return interactive;
+  }
+}

package/templates/firebase/lib/core/widgets/kasy_pressable.dart

@@ -0,0 +1,2 @@
+// Compatibility re-export — use KasyHover directly in new code.
+export 'kasy_hover.dart' show KasyHover;

package/templates/firebase/lib/core/widgets/kasy_pressable_depth.dart

@@ -0,0 +1,161 @@
+import 'dart:async';
+import 'dart:ui' show lerpDouble;
+
+import 'package:flutter/foundation.dart' show kIsWeb;
+import 'package:flutter/material.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+import 'package:kasy_kit/core/haptics/haptic_feedback_notifier.dart';
+
+/// Press-in with slight overshoot-back (same tactility as [KasyAlert] actions).
+///
+/// No Material ripple. Optional [pressOverlayColor] + [clipBorderRadius]:
+/// clarão rápido no tap (véu), não enquanto o dedo apenas descansa em cima.
+/// Também expõe semântica para TalkBack/VoiceOver e haptic leve opcional ([hapticFeedbackEnabled]).
+class KasyPressableDepth extends ConsumerStatefulWidget {
+  final Widget child;
+  final VoidCallback onPressed;
+  final String semanticLabel;
+
+  /// Breve clarão no tap (véu translúcido); não durante o só pressionar.
+  final Color? pressOverlayColor;
+
+  /// Required with [pressOverlayColor] when the surface has rounded clips (pill, etc.).
+  final BorderRadius? clipBorderRadius;
+
+  /// Se false, não chama [HapticFeedback.lightImpact] no tap.
+  final bool hapticFeedbackEnabled;
+
+  const KasyPressableDepth({
+    super.key,
+    required this.child,
+    required this.onPressed,
+    required this.semanticLabel,
+    this.pressOverlayColor,
+    this.clipBorderRadius,
+    this.hapticFeedbackEnabled = true,
+  });
+
+  @override
+  ConsumerState<KasyPressableDepth> createState() => _KasyPressableDepthState();
+}
+
+class _KasyPressableDepthState extends ConsumerState<KasyPressableDepth>
+    with SingleTickerProviderStateMixin {
+  static const double _pressIn = 0.992;
+  static const double _releasePeak = 1.002;
+  late final AnimationController _depthController;
+  Timer? _veilTimer;
+  bool _veilVisible = false;
+
+  bool get _useVeil =>
+      widget.pressOverlayColor != null && widget.clipBorderRadius != null;
+
+  @override
+  void initState() {
+    super.initState();
+    _depthController =
+        AnimationController(
+          vsync: this,
+          duration: const Duration(milliseconds: 300),
+        )..addListener(() {
+          setState(() {});
+        });
+  }
+
+  @override
+  void dispose() {
+    _veilTimer?.cancel();
+    _depthController.dispose();
+    super.dispose();
+  }
+
+  double get _depthScale {
+    final double t = _depthController.value.clamp(0.0, 1.0);
+    if (t <= 0.28) {
+      return lerpDouble(1.0, _pressIn, t / 0.28)!;
+    }
+    if (t <= 0.55) {
+      return lerpDouble(_pressIn, _releasePeak, (t - 0.28) / 0.27)!;
+    }
+    return lerpDouble(_releasePeak, 1.0, (t - 0.55) / 0.45)!;
+  }
+
+  void _handleTap() {
+    if (widget.hapticFeedbackEnabled && ref.read(hapticFeedbackProvider)) {
+      HapticFeedback.lightImpact();
+    }
+    _flashVeil();
+    widget.onPressed();
+    _depthController.forward(from: 0).whenComplete(() {
+      if (mounted) {
+        _depthController.reset();
+      }
+    });
+  }
+
+  void _flashVeil() {
+    if (!_useVeil) {
+      return;
+    }
+    _veilTimer?.cancel();
+    setState(() => _veilVisible = true);
+    _veilTimer = Timer(const Duration(milliseconds: 110), () {
+      if (!mounted) {
+        return;
+      }
+      setState(() => _veilVisible = false);
+    });
+  }
+
+  Widget _wrapScaledChild(Widget rawChild) {
+    if (!_useVeil) {
+      return Transform.scale(scale: _depthScale, child: rawChild);
+    }
+
+    final Widget pressVeil = AnimatedOpacity(
+      duration: const Duration(milliseconds: 90),
+      curve: Curves.easeOutCubic,
+      opacity: _veilVisible ? 1.0 : 0.0,
+      child: IgnorePointer(child: ColoredBox(color: widget.pressOverlayColor!)),
+    );
+
+    return Transform.scale(
+      scale: _depthScale,
+      child: ClipRRect(
+        borderRadius: widget.clipBorderRadius!,
+        child: Stack(
+          fit: StackFit.passthrough,
+          children: <Widget>[
+            rawChild,
+            Positioned.fill(child: pressVeil),
+          ],
+        ),
+      ),
+    );
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    final Widget inner = Semantics(
+      button: true,
+      enabled: true,
+      label: widget.semanticLabel,
+      onTap: _handleTap,
+      child: GestureDetector(
+        behavior: HitTestBehavior.opaque,
+        excludeFromSemantics: true,
+        onTap: _handleTap,
+        child: ConstrainedBox(
+          constraints: const BoxConstraints(minWidth: 44, minHeight: 44),
+          child: Center(child: _wrapScaledChild(widget.child)),
+        ),
+      ),
+    );
+
+    if (!kIsWeb) return inner;
+
+    // On web: show pointer cursor only — no hover highlight.
+    return MouseRegion(cursor: SystemMouseCursors.click, child: inner);
+  }
+}

package/templates/firebase/lib/core/widgets/kasy_scroll_behavior.dart

@@ -0,0 +1,17 @@
+import 'package:flutter/material.dart';
+
+/// Scroll behavior for kit pages: removes the default overscroll **glow** that
+/// uses [ColorScheme.primary] (often reads as a stray blue band when pulling
+/// a list at the top on Android).
+class KasyKitScrollBehavior extends MaterialScrollBehavior {
+  const KasyKitScrollBehavior();
+
+  @override
+  Widget buildOverscrollIndicator(
+    BuildContext context,
+    Widget child,
+    ScrollableDetails details,
+  ) {
+    return child;
+  }
+}

package/templates/firebase/lib/core/widgets/keyboard_visibility.dart

@@ -0,0 +1,75 @@
+import 'package:flutter/material.dart';
+
+enum KeyboardVisibilityState { visible, hidden }
+
+typedef OnKeyboardStateChanged = void Function(KeyboardVisibilityState state);
+
+typedef KeyboardVisibilityBuilder = Widget Function(
+  BuildContext context,
+  Widget child,
+  KeyboardVisibilityState state,
+);
+
+/// A widget that helps you adapt content to the current keyboard visibility.
+/// It uses the Most upper View to get the current keyboard visibility.
+/// A builder is provided to let you adapt the content to the current keyboard visibility.
+/// It will rebuild the content when the keyboard visibility changes.
+class KeyboardVisibility extends StatefulWidget {
+  final Widget child;
+  final OnKeyboardStateChanged? onKeyboardStateChanged;
+  final KeyboardVisibilityBuilder? builder;
+
+  const KeyboardVisibility({
+    super.key,
+    required this.child,
+    this.onKeyboardStateChanged,
+    this.builder,
+  });
+
+  @override
+  State<KeyboardVisibility> createState() => _KeyboardVisibilityState();
+}
+
+class _KeyboardVisibilityState extends State<KeyboardVisibility>
+    with WidgetsBindingObserver {
+  KeyboardVisibilityState? _state;
+
+  @override
+  void initState() {
+    super.initState();
+    WidgetsBinding.instance.addObserver(this);
+  }
+
+  @override
+  void dispose() {
+    WidgetsBinding.instance.removeObserver(this);
+    super.dispose();
+  }
+
+  @override
+  void didChangeMetrics() {
+    super.didChangeMetrics();
+    checkState();
+  }
+
+  void checkState() {
+    final value = WidgetsBinding
+        .instance.platformDispatcher.views.first.viewInsets.bottom;
+    switch (value != 0.0) {
+      case true:
+        widget.onKeyboardStateChanged?.call(KeyboardVisibilityState.visible);
+        setState(() => _state = KeyboardVisibilityState.visible);
+      case false:
+        widget.onKeyboardStateChanged?.call(KeyboardVisibilityState.hidden);
+        setState(() => _state = KeyboardVisibilityState.hidden);
+    }
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    if (widget.builder != null && _state != null) {
+      return widget.builder!(context, widget.child, _state!);
+    }
+    return widget.child;
+  }
+}

package/templates/firebase/lib/core/widgets/page_background.dart

@@ -0,0 +1,71 @@
+import 'package:flutter/material.dart';
+import 'package:kasy_kit/core/theme/theme.dart';
+
+class Background extends StatelessWidget {
+  final Widget child;
+  final String? bgImagePath;
+  final String? bgOverlayImagePath;
+  final Color? bgColor;
+
+  const Background({
+    super.key,
+    required this.child,
+    this.bgOverlayImagePath,
+    this.bgImagePath,
+    this.bgColor,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    return Stack(
+      fit: StackFit.expand,
+      children: <Widget>[
+        Positioned.fill(
+          child: Container(
+            color: bgColor ?? context.colors.background,
+          ),
+        ),
+        if (bgImagePath != null)
+          Positioned.fill(
+            child: Opacity(
+              opacity: .15,
+              child: Container(
+                decoration: BoxDecoration(
+                  image: DecorationImage(
+                    image: AssetImage(bgImagePath!),
+                    fit: BoxFit.cover,
+                  ),
+                ),
+              ),
+            ),
+          ),
+        if (bgOverlayImagePath != null)
+          Positioned.fill(
+            child: Opacity(
+              opacity: .10,
+              child: Container(
+                decoration: BoxDecoration(
+                  image: DecorationImage(
+                    image: AssetImage(bgOverlayImagePath!),
+                    fit: BoxFit.cover,
+                  ),
+                ),
+              ),
+            ),
+          ),
+        Positioned.fill(
+          child: LayoutBuilder(
+            builder: (context, constraints) {
+              return SizedBox(
+                key: const ValueKey("background"),
+                width: constraints.maxWidth,
+                height: constraints.maxHeight,
+                child: child,
+              );
+            },
+          ),
+        ),
+      ],
+    );
+  }
+}

package/templates/firebase/lib/core/widgets/page_not_found.dart

@@ -0,0 +1,15 @@
+import 'package:flutter/material.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+
+class PageNotFound extends StatelessWidget {
+  const PageNotFound({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      body: Center(
+        child: Text(t.page_not_found.title),
+      ),
+    );
+  }
+}