coregen-cli 3.1.6__py3-none-any.whl

generators/static/templates/feature/feature_bloc_template.jinja

@@ -0,0 +1,104 @@
+/*
+ * BLoC (Business Logic Component) template for feature management
+ * Generates a fully functional BLoC with CRUD operations:
+ * - Load: Fetch all items from repository
+ * - Create: Add new item
+ * - Update: Modify existing item  
+ * - Delete: Remove item
+ * 
+ * Uses:
+ * - Freezed for immutable state/events
+ * - Repository pattern for data access
+ */
+
+import 'package:bloc/bloc.dart';
+import 'package:dartz/dartz.dart';
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:[[feature_import_prefix]]/model/[[feature_name]].dart';
+import 'package:[[feature_import_prefix]]/model/[[feature_name]]_failure.dart';
+import 'package:[[feature_import_prefix]]/model/i_[[feature_name]]_repository.dart';
+
+part '[[feature_name]]_event.dart';
+part '[[feature_name]]_state.dart';
+
+part '[[feature_name]]_bloc.freezed.dart';
+
+class [[feature_name.capitalize()]]Bloc extends Bloc<[[feature_name.capitalize()]]Event, [[feature_name.capitalize()]]State> {
+  final I[[feature_name.capitalize()]]Repository _repository;
+
+  [[feature_name.capitalize()]]Bloc(this._repository) : super(const [[feature_name.capitalize()]]State.initial()) {
+    on<LoadRequested>(_onLoadRequested);
+    on<CreateRequested>(_onCreateRequested);
+    on<UpdateRequested>(_onUpdateRequested);
+    on<DeleteRequested>(_onDeleteRequested);
+  }
+
+  Future<void> _onLoadRequested(LoadRequested event, Emitter<[[feature_name.capitalize()]]State> emit) async {
+    emit(const [[feature_name.capitalize()]]State.loading());
+    final Either<[[feature_name.capitalize()]]Failure, List<[[feature_name.capitalize()]]>> result =
+        await _repository.getAll();
+    result.fold(
+      ([[feature_name.capitalize()]]Failure failure) =>
+          emit([[feature_name.capitalize()]]State.error(failure.toString())),
+      (List<[[feature_name.capitalize()]]> items) =>
+          emit([[feature_name.capitalize()]]State.loaded(items)),
+    );
+  }
+
+  Future<void> _onCreateRequested(CreateRequested event, Emitter<[[feature_name.capitalize()]]State> emit) async {
+    emit(const [[feature_name.capitalize()]]State.loading());
+    final Either<[[feature_name.capitalize()]]Failure, Unit> result = await _repository.create(event.item);
+    result.fold(
+      ([[feature_name.capitalize()]]Failure failure) =>
+          emit([[feature_name.capitalize()]]State.error(failure.toString())),
+      (Unit _) async {
+        final Either<[[feature_name.capitalize()]]Failure, List<[[feature_name.capitalize()]]>> itemsResult =
+            await _repository.getAll();
+        itemsResult.fold(
+          ([[feature_name.capitalize()]]Failure failure) =>
+              emit([[feature_name.capitalize()]]State.error(failure.toString())),
+          (List<[[feature_name.capitalize()]]> items) =>
+              emit([[feature_name.capitalize()]]State.loaded(items)),
+        );
+      },
+    );
+  }
+
+  Future<void> _onUpdateRequested(UpdateRequested event, Emitter<[[feature_name.capitalize()]]State> emit) async {
+    emit(const [[feature_name.capitalize()]]State.loading());
+    final Either<[[feature_name.capitalize()]]Failure, Unit> result = await _repository.update(event.item);
+    result.fold(
+      ([[feature_name.capitalize()]]Failure failure) =>
+          emit([[feature_name.capitalize()]]State.error(failure.toString())),
+      (Unit _) async {
+        final Either<[[feature_name.capitalize()]]Failure, List<[[feature_name.capitalize()]]>> itemsResult =
+            await _repository.getAll();
+        itemsResult.fold(
+          ([[feature_name.capitalize()]]Failure failure) =>
+              emit([[feature_name.capitalize()]]State.error(failure.toString())),
+          (List<[[feature_name.capitalize()]]> items) =>
+              emit([[feature_name.capitalize()]]State.loaded(items)),
+        );
+      },
+    );
+  }
+
+  Future<void> _onDeleteRequested(DeleteRequested event, Emitter<[[feature_name.capitalize()]]State> emit) async {
+    emit(const [[feature_name.capitalize()]]State.loading());
+    final Either<[[feature_name.capitalize()]]Failure, Unit> result = await _repository.delete(event.id);
+    result.fold(
+      ([[feature_name.capitalize()]]Failure failure) =>
+          emit([[feature_name.capitalize()]]State.error(failure.toString())),
+      (Unit _) async {
+        final Either<[[feature_name.capitalize()]]Failure, List<[[feature_name.capitalize()]]>> itemsResult =
+            await _repository.getAll();
+        itemsResult.fold(
+          ([[feature_name.capitalize()]]Failure failure) =>
+              emit([[feature_name.capitalize()]]State.error(failure.toString())),
+          (List<[[feature_name.capitalize()]]> items) =>
+              emit([[feature_name.capitalize()]]State.loaded(items)),
+        );
+      },
+    );
+  }
+}

generators/static/templates/feature/feature_dto_template.jinja

@@ -0,0 +1,26 @@
+/*
+ * Data Transfer Object (DTO) template for API communication
+ * Generates a serializable class for network data transfer with:
+ * - JSON serialization/deserialization
+ * - Freezed for immutability and code generation
+ * - Automatic fromJson/toJson methods
+ * 
+ * DTOs represent the data structure expected by the API
+ * and are mapped to/from domain entities in repositories
+ */
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+[[dto_imports]]
+
+part '[[file_name]]_dto.freezed.dart';
+part '[[file_name]]_dto.g.dart';
+
+@freezed
+abstract class [[feature_name]]Dto with _$[[feature_name]]Dto {
+  const factory [[feature_name]]Dto({
+[[fields]]
+  }) = _[[feature_name]]Dto;
+
+  factory [[feature_name]]Dto.fromJson(Map<String, dynamic> json) =>
+      _$[[feature_name]]DtoFromJson(json);
+}

generators/static/templates/feature/feature_entity_template.jinja

@@ -0,0 +1,23 @@
+/*
+ * Entity/Model template for domain objects
+ * Generates an immutable data class using Freezed package
+ * Represents core business objects with:
+ * - Value object integration for type safety
+ * - Immutable properties 
+ * - Auto-generated equality and copyWith methods
+ * 
+ * This is the domain layer model that represents business entities
+ */
+
+import 'package:freezed_annotation/freezed_annotation.dart';
+import 'package:[[project_name]]/core/model/value_objects.dart';
+[[entity_import]]
+
+part '[[file_name]].freezed.dart';
+
+@freezed
+abstract class [[feature_name]] with _$[[feature_name]] {
+  const factory [[feature_name]]({
+[[fields]]
+  }) = _[[feature_name]];
+}

generators/static/templates/feature/feature_event_template.jinja

@@ -0,0 +1,20 @@
+/*
+ * BLoC events template for feature operations
+ * Defines immutable events using Freezed that trigger BLoC actions:
+ * - LoadRequested: Fetch all items
+ * - CreateRequested: Create new item
+ * - UpdateRequested: Update existing item
+ * - DeleteRequested: Remove item by ID
+ * 
+ * Events represent user intentions and trigger state changes
+ */
+
+part of '[[feature_name]]_bloc.dart';
+
+@freezed
+abstract class [[feature_name.capitalize()]]Event with _$[[feature_name.capitalize()]]Event {
+  const factory [[feature_name.capitalize()]]Event.loadRequested() = LoadRequested;
+  const factory [[feature_name.capitalize()]]Event.createRequested([[feature_name.capitalize()]] item) = CreateRequested;
+  const factory [[feature_name.capitalize()]]Event.updateRequested([[feature_name.capitalize()]] item) = UpdateRequested;
+  const factory [[feature_name.capitalize()]]Event.deleteRequested(String id) = DeleteRequested;
+}

generators/static/templates/feature/feature_extensions_template.jinja

@@ -0,0 +1,25 @@
+/*
+ * Extension methods template for data mapping
+ * Generates conversion methods between domain and infrastructure layers:
+ * - DTO to Domain: Convert API data to business objects
+ * - Domain to DTO: Convert business objects for API calls
+ * 
+ * These extensions provide clean separation between:
+ * - Domain layer (business logic)
+ * - Infrastructure layer (API communication)
+ */
+
+import 'package:[[project_name]]/[[feature_name]]/model/[[feature_name]].dart';
+import 'package:[[project_name]]/[[feature_name]]/infrastructure/[[feature_name]]_dto.dart';
+
+extension [[feature_name.capitalize()]]DtoX on [[feature_name.capitalize()]]Dto {
+  [[feature_name.capitalize()]] toDomain() => [[feature_name.capitalize()]](
+[[dto_to_domain_fields]]
+      );
+}
+
+extension [[feature_name.capitalize()]]X on [[feature_name.capitalize()]] {
+  [[feature_name.capitalize()]]Dto toDto() => [[feature_name.capitalize()]]Dto(
+[[domain_to_dto_fields]]
+      );
+}

generators/static/templates/feature/feature_failure_template.jinja

@@ -0,0 +1,11 @@
+import 'package:freezed_annotation/freezed_annotation.dart';
+
+part '[[file_name]]_failure.freezed.dart';
+
+@freezed
+abstract class [[feature_name]]Failure with _$[[feature_name]]Failure {
+  const factory [[feature_name]]Failure.unexpected() = Unexpected;
+  const factory [[feature_name]]Failure.insufficientPermission() = InsufficientPermission;
+  const factory [[feature_name]]Failure.unableToUpdate() = UnableToUpdate;
+  const factory [[feature_name]]Failure.notFound() = NotFound;
+}

generators/static/templates/feature/feature_page_template.jinja

@@ -0,0 +1,113 @@
+/*
+ * Feature page template with full CRUD UI
+ * Generates a complete page with:
+ * - BLoC integration for state management
+ * - List view showing all items
+ * - Add, edit, delete action buttons
+ * - Loading and error state handling
+ * - Navigation ready structure
+ * 
+ * This provides a complete feature page with all basic operations
+ */
+
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:[[project_name]]/injection.dart';
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+import 'package:[[project_name]]/widgets/common/loading_widget.dart';
+import 'package:[[model_import_prefix]]/model/[[model_file_stem]].dart';
+import '../application/[[feature_name]]_bloc.dart';
+
+class [[feature_name.capitalize()]]Page extends StatelessWidget {
+  static const String routeName = '/[[feature_name]]';
+  
+  const [[feature_name.capitalize()]]Page({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return BlocProvider(
+      create: (BuildContext context) => getIt.get<[[feature_name.capitalize()]]Bloc>(),
+      child: Builder(
+        builder: (BuildContext context) {
+          return CustomScaffold(
+            title: CText.title('[[feature_name.replace("_", " ").capitalize()]]', size: TextSize.small),
+            showBackButton: true,
+            action: Row(
+              mainAxisSize: MainAxisSize.min,
+              children: <Widget>[
+                IconButton(
+                  icon: const Icon(Icons.add),
+                  onPressed: () {
+                    // TODO: Navigate to create form
+                  },
+                ),
+                IconButton(
+                  icon: const Icon(Icons.refresh),
+                  onPressed: () {
+                    context.read<[[feature_name.capitalize()]]Bloc>().add(
+                      const [[feature_name.capitalize()]]Event.loadRequested(),
+                    );
+                  },
+                ),
+              ],
+            ),
+            bodyBuilder: (BuildContext context, double topPadding) {
+              return BlocBuilder<[[feature_name.capitalize()]]Bloc, [[feature_name.capitalize()]]State>(
+                builder: (BuildContext context, [[feature_name.capitalize()]]State state) {
+                  return switch (state) {
+                    Initial() => Padding(
+                      padding: EdgeInsets.only(top: topPadding),
+                      child: const Center(child: Text('Welcome')),
+                    ),
+                    Loading() => Padding(
+                      padding: EdgeInsets.only(top: topPadding),
+                      child: const LoadingWidget(),
+                    ),
+                    Loaded(:final items) => ListView.builder(
+                      padding: EdgeInsets.only(top: topPadding, left: 16, right: 16),
+                      itemCount: items.length,
+                      itemBuilder: (BuildContext context, int index) {
+                        final [[model_class_pascal]] item = items[index];
+                        return CTile.simple(
+                          title: item.toString(),
+                          trailing: Row(
+                            mainAxisSize: MainAxisSize.min,
+                            children: <Widget>[
+                              IconButton(
+                                icon: const Icon(Icons.edit),
+                                onPressed: () {
+                                  // TODO: Navigate to edit form
+                                },
+                              ),
+                              IconButton(
+                                icon: const Icon(Icons.delete),
+                                onPressed: () {
+                                  context.read<[[feature_name.capitalize()]]Bloc>().add(
+                                    [[feature_name.capitalize()]]Event.deleteRequested(item.id.getOrCrash()),
+                                  );
+                                },
+                              ),
+                            ],
+                          ),
+                        );
+                      },
+                    ),
+                    Error(:final message) => Padding(
+                      padding: EdgeInsets.only(top: topPadding),
+                      child: Center(child: CText.body('Errore: $message')),
+                    ),
+                    _ => Padding(
+                      padding: EdgeInsets.only(top: topPadding),
+                      child: const Center(child: Text('Stato sconosciuto')),
+                    ),
+                  };
+                },
+              );
+            },
+          );
+        },
+      ),
+    );
+  }
+}

generators/static/templates/feature/feature_repository_template.jinja

@@ -0,0 +1,112 @@
+/*
+ * Repository implementation template with REST API integration
+ * Provides concrete implementation of repository interface with:
+ * - Retrofit for API calls
+ * - Dio HTTP client integration
+ * - DTO to Entity mapping
+ * - Error handling with Either types
+ * - Injectable dependency registration
+ * 
+ * Includes both remote service definition and repository implementation
+ * with proper separation between API layer and domain layer
+ */
+
+import 'package:dartz/dartz.dart';
+import 'package:dio/dio.dart';
+import 'package:injectable/injectable.dart';
+import 'package:retrofit/retrofit.dart';
+[[repo_import]]
+import 'package:[[project_name]]/apis/common/constants.dart';
+
+part '[[feature_name]]_repository.g.dart';
+
+@module
+abstract class [[feature_name.capitalize()]]RemoteModule {
+  @preResolve
+  @LazySingleton()
+  Future<[[feature_name.capitalize()]]RemoteService> [[feature_name]]RemoteService(Dio dio) async {
+    return [[feature_name.capitalize()]]RemoteService(dio, baseUrl: Constants.apiUrl);
+  }
+}
+
+@RestApi()
+abstract class [[feature_name.capitalize()]]RemoteService {
+  @factoryMethod
+  factory [[feature_name.capitalize()]]RemoteService(Dio dio, {String baseUrl}) = _[[feature_name.capitalize()]]RemoteService;
+
+  @GET('/[[feature_name]]s')
+  Future<List<[[feature_name.capitalize()]]Dto>> getAllDto();
+
+  @GET('/[[feature_name]]s/{id}')
+  Future<[[feature_name.capitalize()]]Dto> getByIdDto(@Path('id') String id);
+
+  @POST('/[[feature_name]]s')
+  Future<void> createDto(@Body() [[feature_name.capitalize()]]Dto [[feature_name]]Dto);
+
+  @PUT('/[[feature_name]]s/{id}')
+  Future<void> updateDto(@Path('id') String id, @Body() [[feature_name.capitalize()]]Dto [[feature_name]]Dto);
+
+  @DELETE('/[[feature_name]]s/{id}')
+  Future<void> deleteDto(@Path('id') String id);
+}
+
+@Injectable(as: I[[feature_name.capitalize()]]Repository)
+class [[feature_name.capitalize()]]Repository implements I[[feature_name.capitalize()]]Repository {
+  final [[feature_name.capitalize()]]RemoteService _remoteService;
+
+  [[feature_name.capitalize()]]Repository(this._remoteService);
+
+  @override
+  Future<Either<[[feature_name.capitalize()]]Failure, List<[[feature_name.capitalize()]]>>> getAll() async {
+    try {
+      final List<[[feature_name.capitalize()]]Dto> dtos = await _remoteService.getAllDto();
+      final List<[[feature_name.capitalize()]]> domain = dtos
+          .map(([[feature_name.capitalize()]]Dto dto) => dto.toDomain())
+          .toList();
+      return right(domain);
+    } on Object catch (_) {
+      return left(const [[feature_name.capitalize()]]Failure.unexpected());
+    }
+  }
+
+  @override
+  Future<Either<[[feature_name.capitalize()]]Failure, [[feature_name.capitalize()]]>> getById(String id) async {
+    try {
+      final [[feature_name.capitalize()]]Dto dto = await _remoteService.getByIdDto(id);
+      final [[feature_name.capitalize()]] domain = dto.toDomain();
+      return right(domain);
+    } on Object catch (_) {
+      return left(const [[feature_name.capitalize()]]Failure.unexpected());
+    }
+  }
+
+  @override
+  Future<Either<[[feature_name.capitalize()]]Failure, Unit>> create([[feature_name.capitalize()]] item) async {
+    try {
+      await _remoteService.createDto(item.toDto());
+      return right(unit);
+    } on Object catch (_) {
+      return left(const [[feature_name.capitalize()]]Failure.unexpected());
+    }
+  }
+
+  @override
+  Future<Either<[[feature_name.capitalize()]]Failure, Unit>> update([[feature_name.capitalize()]] item) async {
+    try {
+      await _remoteService.updateDto(item.id.getOrCrash(), item.toDto());
+      return right(unit);
+    } on Object catch (_) {
+      return left(const [[feature_name.capitalize()]]Failure.unexpected());
+    }
+  }
+
+  @override
+  Future<Either<[[feature_name.capitalize()]]Failure, Unit>> delete(String id) async {
+    try {
+      await _remoteService.deleteDto(id);
+      return right(unit);
+    } on Object catch (_) {
+      return left(const [[feature_name.capitalize()]]Failure.unexpected());
+    }
+  }
+}

generators/static/templates/feature/feature_state_template.jinja

@@ -0,0 +1,20 @@
+/*
+ * BLoC states template for feature UI representation
+ * Defines immutable states using Freezed for different UI states:
+ * - Initial: App just started, no data loaded
+ * - Loading: Data is being fetched/processed
+ * - Loaded: Data successfully retrieved with items list
+ * - Error: Something went wrong with error message
+ * 
+ * States represent the current condition of the feature
+ */
+
+part of '[[feature_name]]_bloc.dart';
+
+@freezed
+abstract class [[feature_name.capitalize()]]State with _$[[feature_name.capitalize()]]State {
+  const factory [[feature_name.capitalize()]]State.initial() = Initial;
+  const factory [[feature_name.capitalize()]]State.loading() = Loading;
+  const factory [[feature_name.capitalize()]]State.loaded(List<[[feature_name.capitalize()]]> items) = Loaded;
+  const factory [[feature_name.capitalize()]]State.error(String message) = Error;
+}

generators/static/templates/feature/i_feature_repository_template.jinja

@@ -0,0 +1,21 @@
+/*
+ * Repository interface template for data access abstraction
+ * Defines the contract for data operations using:
+ * - Either type for error handling (Left = failure, Right = success)
+ * - CRUD operations (Create, Read, Update, Delete)
+ * - Async operations returning Futures
+ * 
+ * This interface allows different implementations (API, local storage, etc.)
+ * while keeping the business logic independent of data source
+ */
+
+import 'package:dartz/dartz.dart';
+[[i_repo_import]]
+
+abstract class I[[feature_name]]Repository {
+  Future<Either<[[feature_name]]Failure, List<[[feature_name]]>>> getAll();
+  Future<Either<[[feature_name]]Failure, [[feature_name]]>> getById(String id);
+  Future<Either<[[feature_name]]Failure, Unit>> create([[feature_name]] item);
+  Future<Either<[[feature_name]]Failure, Unit>> update([[feature_name]] item);
+  Future<Either<[[feature_name]]Failure, Unit>> delete(String id);
+}

generators/static/templates/feature/value_validators_template.jinja

@@ -0,0 +1,57 @@
+/*
+ * Value validators template for input validation
+ * Generates validation functions for different data types:
+ * - String validation (empty check and custom rules)
+ * - Numeric validation (int, double)
+ * - Boolean validation  
+ * - DateTime validation
+ * 
+ * Uses Either types for functional error handling
+ * Returns validation failures or valid values
+ */
+
+import 'package:dartz/dartz.dart';
+import 'package:[[project_name]]/core/model/failures.dart';
+
+{% for field in field_list %}
+{% if field.name != 'id' %}
+{% if field.type == 'String' %}
+Either<ValueFailure<String>, String> validate[[field.pascal_name]](String input) {
+  if (input.isEmpty) {
+    return left(ValueFailure.empty(failedValue: input));
+  }
+  // Additional string validations can be added here
+  return right(input);
+}
+{% elif field.type == 'int' %}
+Either<ValueFailure<int>, int> validate[[field.pascal_name]](int input) {
+  // Additional int validations can be added here
+  return right(input);
+}
+{% elif field.type == 'double' %}
+Either<ValueFailure<double>, double> validate[[field.pascal_name]](double input) {
+  // Additional double validations can be added here
+  return right(input);
+}
+{% elif field.type == 'bool' %}
+Either<ValueFailure<bool>, bool> validate[[field.pascal_name]](bool input) {
+  // Boolean validation - always valid
+  // Additional boolean validations can be added here
+  return right(input);
+}
+{% elif field.type == 'DateTime' %}
+Either<ValueFailure<DateTime>, DateTime> validate[[field.pascal_name]](DateTime input) {
+  // Additional datetime validations can be added here
+  return right(input);
+}
+{% else %}
+Either<ValueFailure<String>, String> validate[[field.pascal_name]](String input) {
+  if (input.isEmpty) {
+    return left(ValueFailure.empty(failedValue: input));
+  }
+  // Additional string validations can be added here
+  return right(input);
+}
+{% endif %}
+{% endif %}
+{% endfor %}

generators/static/templates/home/home_screen_template.jinja

@@ -0,0 +1,68 @@
+/*
+ * Home screen template with navigation structure
+ * Generates the main application screen with:
+ * - Bottom navigation bar integration
+ * - Multiple tab screens based on configuration
+ * - Optional drawer support
+ * - StatefulWidget for navigation state management
+ * 
+ * This serves as the main navigation hub for the application
+ * with configurable navigation items and screens
+ */
+
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart';
+import 'package:[[project_name]]/core/presentation/bottom_nav_bar.dart';
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+{% for nav_item in nav_items %}
+import 'package:[[project_name]]/features/home/[[nav_item.name]]_screen.dart';
+{% endfor %}
+{% if has_drawer %}
+import 'package:[[project_name]]/core/presentation/app_drawer.dart';
+{% endif %}
+
+class HomePage extends StatefulWidget {
+  static const String routeName = '/home';
+
+  const HomePage({super.key});
+
+  @override
+  State<HomePage> createState() => _HomePageState();
+}
+
+class _HomePageState extends State<HomePage> {
+  int _selectedIndex = 0;
+
+  final List<Widget> _pages = [
+    const Center(child: Text('Home Content')),
+{% for nav_item in nav_items %}
+    const [[nav_item.name|title]]Screen(),
+{% endfor %}
+  ];
+
+  void _onItemTapped(int index) {
+    setState(() {
+      _selectedIndex = index;
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return CustomScaffold(
+      title: CText.title('Home', size: TextSize.medium).bold,
+      showBackButton: false,
+{% if has_drawer %}
+      drawer: const AppDrawer(),
+{% endif %}
+      body: Column(
+        children: <Widget>[
+          Expanded(child: _pages[_selectedIndex]),
+          BottomNavBar(
+            currentIndex: _selectedIndex,
+            onTap: _onItemTapped,
+          ),
+        ],
+      ),
+    );
+  }
+}

generators/static/templates/home/presentation/home_screen_template.jinja

@@ -0,0 +1,52 @@
+import 'package:caravaggio_ui/caravaggio_ui.dart';
+import 'package:flutter/material.dart';
+{% if has_login %}
+import 'package:flutter_bloc/flutter_bloc.dart';
+import 'package:go_router/go_router.dart';
+import 'package:[[project_name]]/features/auth/application/auth_bloc.dart';
+import 'package:[[project_name]]/features/auth/presentation/login_page.dart';
+{% endif %}
+import 'package:[[project_name]]/widgets/common/custom_scaffold.dart';
+
+class HomePage extends StatefulWidget {
+  static const String routeName = '/home';
+
+  const HomePage({super.key});
+
+  @override
+  State<HomePage> createState() => _HomePageState();
+}
+
+class _HomePageState extends State<HomePage> {
+  @override
+  Widget build(BuildContext context) {
+{% if has_login %}
+    return BlocListener<AuthBloc, AuthState>(
+      listener: (BuildContext context, AuthState state) => switch (state) {
+        Unauthenticated() => context.go(LoginPage.routeName),
+        _ => null,
+      },
+      child: CustomScaffold(
+        title: CText.title('Home', size: TextSize.medium).bold,
+        showBackButton: false,
+        action: CButton.icon(
+          icon: Icons.logout,
+          tooltip: 'Logout',
+          onPressed: () => context.read<AuthBloc>().add(const AuthEvent.signedOut()),
+        ),
+        body: const Center(
+          child: Text('Home Screen'),
+        ),
+      ),
+    );
+{% else %}
+    return CustomScaffold(
+      title: CText.title('Home', size: TextSize.medium).bold,
+      showBackButton: false,
+      body: const Center(
+        child: Text('Home Screen'),
+      ),
+    );
+{% endif %}
+  }
+}