kasy-cli 1.37.1 → 1.39.0

package/templates/firebase/lib/main.dart

@@ -199,13 +199,26 @@ class _MyAppState extends ConsumerState<MyApp> {
                     facebookEventApiProvider,
                   ],
                   onReady: FocusVisibility(
-                    child: WebViewportScale.wrap(
-                      DevicePreview.appBuilder(
-                        context,
-                        ResponsiveTextTheme(
-                          child: child ?? const SizedBox.shrink(),
-                        ),
-                      ),
+                    child: ValueListenableBuilder<bool>(
+                      valueListenable: webDevicePreviewActiveNotifier,
+                      builder: (context, devicePreviewActive, _) {
+                        final Widget app = DevicePreview.appBuilder(
+                          context,
+                          ResponsiveTextTheme(
+                            child: child ?? const SizedBox.shrink(),
+                          ),
+                        );
+                        // The web render-scale correction applies to the REAL
+                        // web app on every breakpoint. Once the device preview
+                        // frame is actually on screen it simulates a NATIVE
+                        // device, so it renders at native 1.0 — skip the scale.
+                        // Gated on the *active* (frame-built) notifier, not the
+                        // raw toggle, so the scale only drops when the frame is
+                        // up (no flash of big unframed app while it builds).
+                        return devicePreviewActive
+                            ? app
+                            : WebViewportScale.wrap(app);
+                      },
                     ),
                   ),
                   onError: (_, error) => InitializationErrorPage(error: error),

package/templates/firebase/lib/router.dart

@@ -26,9 +26,7 @@ import 'package:kasy_kit/features/local_reminders/ui/reminder_page.dart';
 import 'package:kasy_kit/features/onboarding/ui/onboarding_page.dart';
 import 'package:kasy_kit/features/settings/ui/components/admin/admin_home_widgets.dart';
 import 'package:kasy_kit/features/settings/ui/components/admin/admin_page.dart';
-import 'package:kasy_kit/features/settings/ui/components/admin/admin_paywalls.dart';
 import 'package:kasy_kit/features/settings/ui/components/admin/admin_routes.dart';
-import 'package:kasy_kit/features/settings/ui/components/admin/send_push_notification_page.dart';
 import 'package:kasy_kit/features/subscriptions/ui/component/premium_page_factory.dart';
 import 'package:kasy_kit/features/subscriptions/ui/premium_page.dart';
 import 'package:logger/logger.dart';
@@ -71,6 +69,16 @@ String? _authRedirect(Ref ref, GoRouterState state) {
   // redirect yet — we re-run once the state resolves (refresh listenable).
   if (user.isLoading) return null;
 
+  // Admin area is role-gated at the ROUTING layer (URLs included), not just by
+  // hiding UI: in production, /admin and every /admin/* section open only for an
+  // authenticated admin (role == "admin"). Anyone else — including someone who
+  // types the URL directly — is bounced home. Open in debug for development.
+  // This sits on top of the server-side data rules that ultimately protect the
+  // data; here it guarantees the screens themselves are never even reachable.
+  if (state.uri.path.startsWith('/admin') && !kDebugMode && !user.isAdmin) {
+    return '/';
+  }
+
   final String loc = state.matchedLocation;
   final bool onAuthRoute = _authRoutes.contains(loc);
   final bool onboardingDone = ref
@@ -212,7 +220,11 @@ GoRouter generateRouter({
         path: '/onboarding',
         pageBuilder: (context, state) => kasyTransitionPage(
           key: state.pageKey,
-          child: const OnboardingPage(),
+          // ?preview=true opens the flow as a side-effect-free walkthrough from
+          // the admin Debug screen (no account creation, returns to Debug).
+          child: OnboardingPage(
+            preview: state.uri.queryParameters['preview'] == 'true',
+          ),
         ),
       ),
       GoRoute(
@@ -296,25 +308,65 @@ GoRouter generateRouter({
           child: const RecoverPasswordPage(),
         ),
       ),
-      // Admin console: registered always so administrators reach it in release
-      // builds too. Access is gated inside AdminPage (admin role || debug).
-      GoRoute(
-        name: 'admin',
-        path: '/admin',
-        pageBuilder: (context, state) => kasyTransitionPage(
+      // Admin console: a StatefulShellRoute so every section is a real,
+      // URL-addressable screen that keeps its own state while the navigation
+      // rail persists across them. The top-level sections (/admin, /admin/users,
+      // /admin/requests) and the four "Ferramentas" sub-screens (/admin/tools/*)
+      // are ALL branches — each its own URL, reached from the sidebar. Registered
+      // always (admins reach it in release too); the redirect above blocks
+      // /admin* for non-admins in production. adminSections() is the single
+      // source the sidebar reads too, so branches and nav rows stay aligned.
+      StatefulShellRoute.indexedStack(
+        // Enter /admin with the app's standard page transition
+        // (KasyNavigationConfig.push), same as every other route — pageBuilder
+        // (not builder), otherwise go_router falls back to its default platform
+        // transition. Switching sections is instant (IndexedStack), like tabs.
+        pageBuilder: (context, state, navigationShell) => kasyTransitionPage(
           key: state.pageKey,
-          child: const AdminPage(),
+          child: AdminShell(navigationShell: navigationShell),
         ),
+        branches: [
+          for (final section in adminSections())
+            StatefulShellBranch(
+              routes: [
+                GoRoute(
+                  path: section.path,
+                  pageBuilder: (context, state) => kasyTransitionPage(
+                    key: state.pageKey,
+                    child: section.build(),
+                  ),
+                ),
+              ],
+            ),
+        ],
       ),
-      if (kDebugMode) ...[
-        GoRoute(
-          name: 'admin_paywalls',
-          path: adminRoutePaywalls,
-          pageBuilder: (context, state) => kasyTransitionPage(
+      // Drill-downs pushed full-screen from inside the console (their own back
+      // button) — the redirect above keeps /admin* admin-only.
+      //
+      // Paywall variant preview is pushed from the Paywalls section, which ships
+      // in production, so it's registered always.
+      GoRoute(
+        name: 'admin_premium_preview',
+        path: '/admin/premium/:variant',
+        pageBuilder: (context, state) {
+          final paywall = paywallFactoryFromAdminRoute(
+            state.pathParameters['variant'],
+          );
+          if (paywall == null || !withRevenuecat) {
+            return kasyTransitionPage(
+              key: state.pageKey,
+              child: const PageNotFound(),
+            );
+          }
+          return kasyTransitionPage(
             key: state.pageKey,
-            child: const AdminPaywalls(),
-          ),
-        ),
+            child: PremiumPage(paywall: paywall),
+          );
+        },
+      ),
+      // Home-widgets panel: developer-only, pushed from the Debug section's
+      // (debug-gated) tile — its route registers only in kDebugMode.
+      if (kDebugMode)
         GoRoute(
           name: 'admin_home_widgets',
           path: adminRouteHomeWidgets,
@@ -323,34 +375,6 @@ GoRouter generateRouter({
             child: const AdminHomeWidgets(),
           ),
         ),
-        GoRoute(
-          name: 'admin_premium_preview',
-          path: '/admin/premium/:variant',
-          pageBuilder: (context, state) {
-            final paywall = paywallFactoryFromAdminRoute(
-              state.pathParameters['variant'],
-            );
-            if (paywall == null || !withRevenuecat) {
-              return kasyTransitionPage(
-                key: state.pageKey,
-                child: const PageNotFound(),
-              );
-            }
-            return kasyTransitionPage(
-              key: state.pageKey,
-              child: PremiumPage(paywall: paywall),
-            );
-          },
-        ),
-      ],
-      GoRoute(
-        name: 'send_push',
-        path: adminRouteSendPush,
-        pageBuilder: (context, state) => kasyTransitionPage(
-          key: state.pageKey,
-          child: const SendPushNotificationPage(),
-        ),
-      ),
       GoRoute(
         name: '404',
         path: '/404',

package/templates/firebase/pubspec.yaml

@@ -16,7 +16,7 @@ publish_to: 'none' # Remove this line if you wish to publish to pub.dev
 # https://developer.apple.com/library/archive/documentation/General/Reference/InfoPlistKeyReference/Articles/CoreFoundationKeys.html
 # In Windows, build-name is used as the major, minor, and patch parts
 # of the product and file versions while build-number is used as the build suffix.
-version: 1.0.0+58
+version: 1.0.0+66
 
 environment:
   sdk: ^3.11.0
@@ -59,6 +59,7 @@ dependencies:
   flutter_native_splash: ^2.4.7
   flutter_riverpod: ^3.1.0
   flutter_secure_storage: ^9.2.4
+  flutter_svg: ^2.3.0
   flutter_timezone: ^5.0.1
   freezed_annotation: ^3.1.0
   go_router: ^17.1.0

package/templates/firebase/test/admin_shell_chrome_test.dart

@@ -0,0 +1,110 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:go_router/go_router.dart';
+import 'package:kasy_kit/components/kasy_app_bar.dart';
+import 'package:kasy_kit/components/kasy_sidebar.dart';
+import 'package:kasy_kit/core/data/models/user.dart';
+import 'package:kasy_kit/core/states/models/user_state.dart';
+import 'package:kasy_kit/features/settings/ui/components/admin/admin_page.dart';
+import 'package:kasy_kit/features/settings/ui/components/admin/admin_routes.dart';
+import 'package:kasy_kit/i18n/translations.g.dart';
+
+import 'test_utils.dart';
+
+/// Mirrors the real admin shell: every section (top-level AND the "Ferramentas"
+/// sub-screens) is its own branch, so they all share the same chrome and a
+/// persistent rail. Branch order/paths match [adminSections] so the shell's
+/// currentIndex lines up; the branch bodies are placeholders so the test stays
+/// focused on the chrome (sidebar + header), not on each page's providers.
+GoRouter _adminTestRouter(String initial) => GoRouter(
+  initialLocation: initial,
+  routes: [
+    GoRoute(path: '/', builder: (_, _) => const SizedBox()),
+    StatefulShellRoute.indexedStack(
+      builder: (c, s, shell) => AdminShell(navigationShell: shell),
+      branches: [
+        for (final section in adminSections())
+          StatefulShellBranch(
+            routes: [
+              GoRoute(
+                path: section.path,
+                builder: (_, _) =>
+                    Center(child: Text('section-${section.id.name}')),
+              ),
+            ],
+          ),
+      ],
+    ),
+  ],
+);
+
+UserState _adminUser() => UserState(
+  user: User.authenticated(
+    id: '1',
+    email: 'admin@email.com',
+    name: 'Admin',
+    onboarded: true,
+    role: 'admin',
+    creationDate: DateTime.now(),
+  ),
+);
+
+/// The desktop application bar is a [KasyAppBar.application] — same class as the
+/// page bar, told apart by [KasyAppBar.isApplication].
+final Finder _applicationBar = find.byWidgetPredicate(
+  (Widget w) => w is KasyAppBar && w.isApplication,
+);
+
+void main() {
+  testWidgets(
+    'admin section (desktop) renders the real KasySidebar + application bar',
+    (tester) async {
+      tester.view.physicalSize = const Size(1400, 900);
+      tester.view.devicePixelRatio = 1.0;
+      addTearDown(tester.view.resetPhysicalSize);
+      addTearDown(tester.view.resetDevicePixelRatio);
+
+      await tester.pumpPage(
+        userState: _adminUser(),
+        routerConfig: _adminTestRouter('/admin'),
+      );
+      await tester.pump(const Duration(milliseconds: 300));
+
+      // The console uses the app's real chrome components, not a bespoke copy.
+      expect(find.byType(KasySidebar), findsOneWidget);
+      expect(_applicationBar, findsOneWidget);
+      expect(find.text('section-overview'), findsOneWidget);
+    },
+  );
+
+  testWidgets(
+    'a Ferramentas sub-screen (desktop) is a real section: same rail + header, '
+    'submenu open',
+    (tester) async {
+      tester.view.physicalSize = const Size(1400, 900);
+      tester.view.devicePixelRatio = 1.0;
+      addTearDown(tester.view.resetPhysicalSize);
+      addTearDown(tester.view.resetDevicePixelRatio);
+
+      await tester.pumpPage(
+        userState: _adminUser(),
+        routerConfig: _adminTestRouter(adminRouteSendPush),
+      );
+      await tester.pump(const Duration(milliseconds: 300));
+
+      // Tools sub-screens get the SAME chrome as every other section now (the
+      // whole point of this change): the persistent rail AND the application bar.
+      expect(find.byType(KasySidebar), findsOneWidget);
+      expect(_applicationBar, findsOneWidget);
+      expect(find.text('section-sendPush'), findsOneWidget);
+
+      // The rail shows the "Ferramentas" group, auto-expanded because one of its
+      // children (Send push) is the active screen.
+      expect(find.text(t.admin_console.tabs.tools), findsOneWidget);
+      expect(
+        find.text(t.home.features_page.send_push_title),
+        findsWidgets,
+      );
+    },
+  );
+}

package/templates/firebase/test/components/kasy_text_field_height_test.dart

@@ -0,0 +1,77 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:kasy_kit/components/kasy_text_field.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/responsive_text_theme.dart';
+import 'package:kasy_kit/core/theme/texts.dart';
+import 'package:kasy_kit/core/theme/universal_theme.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+
+import '../device_test_utils.dart';
+
+/// A single-line [KasyTextField] must render at exactly
+/// [KasyTextField.singleLineHeight] on EVERY breakpoint. The height is locked
+/// with a forced strut (see kasy_text_field.dart) precisely so it cannot drift
+/// between renderers (web CanvasKit vs native) or viewport widths. Run this on
+/// the VM and with `--platform chrome` to cover both renderers.
+void main() {
+  Widget appWithField() {
+    return Builder(builder: (context) {
+      return MaterialApp(
+        theme: ThemeProvider.of(context).light,
+        home: const ResponsiveTextTheme(
+          child: Scaffold(
+            body: Center(
+              child: SizedBox(
+                width: 320,
+                child: KasyTextField(
+                  hint: 'Email',
+                  variant: KasyTextFieldVariant.flat,
+                ),
+              ),
+            ),
+          ),
+        ),
+      );
+    });
+  }
+
+  testWidgets('single-line field height stays locked across breakpoints',
+      (tester) async {
+    SharedPreferences.setMockInitialValues({});
+    final sharedPrefs = await SharedPreferences.getInstance();
+
+    final widget = ThemeProvider(
+      notifier: AppTheme.uniform(
+        sharedPreferences: sharedPrefs,
+        themeFactory: const UniversalThemeFactory(),
+        lightColors: KasyColors.light(),
+        darkColors: KasyColors.dark(),
+        textTheme: KasyTextTheme.build(),
+        defaultMode: ThemeMode.light,
+      ),
+      child: appWithField(),
+    );
+
+    const breakpoints = <Device>[
+      Device(name: 'mobile', width: 375, height: 812, pixelDensity: 3),
+      Device(name: 'tablet', width: 800, height: 1024, pixelDensity: 2),
+      Device(name: 'desktop', width: 1400, height: 900, pixelDensity: 1),
+    ];
+
+    for (final device in breakpoints) {
+      await tester.setScreenSize(device);
+      await tester.pumpWidget(widget);
+      await tester.pumpAndSettle();
+      final double boxHeight =
+          tester.getSize(find.byType(TextField).first).height;
+      expect(
+        boxHeight,
+        KasyTextField.singleLineHeight,
+        reason: 'field box should be ${KasyTextField.singleLineHeight}px on '
+            '${device.name} (${device.width}px wide), got $boxHeight',
+      );
+    }
+  });
+}

package/templates/firebase/test/core/web_viewport_scale_test.dart

@@ -1,28 +1,34 @@
 import 'package:flutter_test/flutter_test.dart';
 import 'package:kasy_kit/core/web_viewport_scale.dart';
 
-/// Locks the desktop web scaling behaviour so a future change to the constants or
-/// the formula can't silently regress it. The headline rule, and the bug this
-/// guards against: the desktop compensation must key off the SCREEN width (OS
-/// scale), NOT the window width — merely resizing the browser window must not
-/// shrink the UI; the extra shrink happens only when the screen itself is small.
+/// Locks the web scaling behaviour so a future change to the constants or the
+/// formula can't silently regress it. Two headline rules:
+/// - the flat cap applies on EVERY web breakpoint (phone/tablet/desktop) so the
+///   whole web app matches native, with no size jump at the desktop breakpoint;
+/// - the desktop high-OS-scale compensation must key off the SCREEN width, NOT
+///   the window width — merely resizing the browser window must not shrink the
+///   UI further; the extra shrink happens only when the screen itself is small.
 void main() {
   group('webViewportEffectiveScale', () {
-    test('no scaling below the desktop breakpoint (mobile/tablet web == native)',
+    test('flat cap applies on tablet/phone web too (no jump at the breakpoint)',
         () {
-      // The window width decides the breakpoint (the layout follows the window),
-      // so below it the scale is 1.0 regardless of the screen — same as native
-      // and the device preview.
-      expect(webViewportEffectiveScale(375), 1.0); // phone
-      expect(webViewportEffectiveScale(900), 1.0); // tablet
-      expect(webViewportEffectiveScale(900, screenWidth: 1470), 1.0);
+      // Below the desktop breakpoint the scale is the flat cap (not 1.0): the
+      // same ~10% web oversize is corrected, and there is no size jump when the
+      // window crosses the desktop breakpoint. Compensation is desktop-only, so
+      // the screen width is ignored here.
+      expect(webViewportEffectiveScale(375), kWebViewportScale); // phone
+      expect(webViewportEffectiveScale(900), kWebViewportScale); // tablet
+      expect(webViewportEffectiveScale(900, screenWidth: 1470), kWebViewportScale);
+      // A small screen does NOT compensate below the breakpoint — that is a
+      // desktop-only concern; tablet/phone always take the flat cap.
+      expect(webViewportEffectiveScale(900, screenWidth: 300), kWebViewportScale);
       expect(
         webViewportEffectiveScale(kWebViewportScaleDesktopBreakpoint - 1),
-        1.0,
+        kWebViewportScale,
       );
     });
 
-    test('desktop on a normal/large screen stays at the flat cap (0.95)', () {
+    test('desktop on a normal/large screen stays at the flat cap', () {
       // Unknown screen (null) → flat cap.
       expect(webViewportEffectiveScale(1280), kWebViewportScale);
       expect(webViewportEffectiveScale(1500), kWebViewportScale);
@@ -43,7 +49,7 @@ void main() {
     });
 
     test('high OS scale (small SCREEN) compensates below the cap', () {
-      // Drop below 0.95 only because the screen is small — independent of window.
+      // Drop below the cap only because the screen is small — independent of window.
       expect(webViewportEffectiveScale(1024, screenWidth: 1024), closeTo(0.80, 1e-4));
       expect(webViewportEffectiveScale(1097, screenWidth: 1097), closeTo(0.857, 1e-3));
       // Even a wide window on a small (high-scale) screen compensates.
@@ -58,7 +64,8 @@ void main() {
     });
 
     test('the maxScale override is respected as the cap', () {
-      expect(webViewportEffectiveScale(1920, screenWidth: 1920, maxScale: 0.9), 0.9);
+      // Use a non-default cap so this genuinely exercises the override.
+      expect(webViewportEffectiveScale(1920, screenWidth: 1920, maxScale: 0.8), 0.8);
     });
 
     test('an absurdly small screen is clamped to the 0.5 floor', () {

package/templates/firebase/test/features/authentication/data/api/user_api_fake.dart

@@ -83,4 +83,7 @@ class FakeUserApi implements UserApi {
   Future<void> updateLocale(String userId, String locale) {
     return Future.value();
   }
+
+  @override
+  Stream<String?> watchRole(String id) => const Stream.empty();
 }

package/templates/firebase/tool/design_check.dart

@@ -77,6 +77,15 @@ final List<_Rule> _rules = <_Rule>[
     RegExp(r'Color\(0x|(?<![A-Za-z])Colors\.(?!transparent\b)(?!white)(?!black)[A-Za-z]'),
     'Use a colour token (context.colors.*) instead of a raw Color/Colors value.',
   ),
+  _Rule(
+    'hardcoded-radius',
+    // A numeric literal right after `circular(` — catches BorderRadius.circular(16),
+    // Radius.circular(8) and the only/vertical/horizontal forms (they nest a
+    // Radius.circular). `circular(KasyRadius.lg)` starts with a letter, so it
+    // passes; `circular(size / 2)` likewise (calibrated, not a token miss).
+    RegExp(r'\bcircular\(\s*\d'),
+    'Use a KasyRadius.* token instead of a literal corner radius.',
+  ),
 ];
 
 // The icon rule needs two signals on the same line, so it is handled separately.