Last time I tried not to pull the message variable in the splash view, it did not see the variable inside the object.

Splash View for example

@RoutePage()
class SplashView extends BaseView {
  SplashView({super.key});

  @override
  Widget build(BuildContext context) {
    return BlocProvider(
      create: (_) => SplashController(),
      child: BaseCubitWidget(
        bloc: SplashController(),
        blocType: BlocType.both,
        initial: <SplashModel>(BaseInitialModel<SplashModel> state) {
          final SplashModel splashData = state.data?.data as SplashModel;
          return Container(
            child: Text(splashData!.message ?? 'Başlık yok'), // here is the problem 
          );
        },
      ),
    );
  }
}

// base cubit widget

part 'base_cubit_widget_mixin.dart';

part 'state_widget_builder.dart';

typedef InitialBuilder<T> = Widget Function(BaseInitialModel<T> state);

typedef ErrorBuilder<T> = Widget Function(
  BaseErrorModel<T> state,
)?;

typedef LoadingBuilder<T> = Widget Function(
  BaseLoadingModel<T> state,
)?;

typedef ListenerFunction = void Function(
  BuildContext,
  BaseState<dynamic>,
)?;

typedef ListenWhenFunction<T> = bool Function(
  BaseState<T>,
  BaseState<T>,
)?;

class BaseCubitWidget extends StatelessWidget with _BaseCubitWidgetMixin {
  BaseCubitWidget({
    super.key,
    required this.bloc,
    this.blocType = BlocType.builder,
    this.listener,
    this.listenerChild,
    this.listenWhen,
    required this.initial,
    this.error,
    this.loading,
  }) {
    _assertions(blocType, initial, error, loading, listener, listenerChild);
  }

  final StateStreamable<BaseState<dynamic>> bloc;

  final BlocType blocType;

  final ListenerFunction? listener;

  final Widget? listenerChild;

  final ListenWhenFunction<dynamic> listenWhen;

  final InitialBuilder<dynamic>? initial;
  final ErrorBuilder<dynamic>? error;
  final LoadingBuilder<dynamic>? loading;

  @override
  Widget build(BuildContext context) {
    switch (blocType) {
      case BlocType.builder:
        return BlocBuilder<StateStreamable<BaseState<dynamic>>,
            BaseState<dynamic>>(
          builder: (context, state) {
            return _buildBlocBuilder(context);
          },
          bloc: bloc,
        );

      case BlocType.listener:
        return BlocListener<StateStreamable<BaseState<dynamic>>,
            BaseState<dynamic>>(
          listener: listener!,
          bloc: bloc,
          listenWhen: listenWhen,
          child: listenerChild ?? _buildBlocBuilder(context),
        );

      case BlocType.both:
        return BlocConsumer<StateStreamable<BaseState<dynamic>>,
            BaseState<dynamic>>(
          builder: (context, state) {
            return _buildBlocBuilder(context);
          },
          listener: listener!,
        );
    }
  }

  Widget _buildBlocBuilder(BuildContext context) {
    return BlocBuilder<StateStreamable<BaseState<dynamic>>, BaseState<dynamic>>(
      bloc: bloc,
      builder: (context, state) {
        return _StateWidgetBuilder(
          state: state,
          initial: initial!,
          error: error,
          loading: loading,
        );
      },
    );
  }
}

enum BlocType {
  builder,
  listener,
  both,
}

// base state

sealed class BaseState<T> extends Equatable {
  const BaseState();

  factory BaseState.initial({BaseInitialDataModel<T>? data}) {
    return BaseInitialModel<T>(
      data: data,
    );
  }

  factory BaseState.loading({BaseLoadingDataModel<T>? data}) {
    return BaseLoadingModel<T>(
      data: data,
    );
  }

  factory BaseState.error({BaseErrorDataModel<T>? data}) {
    return BaseErrorModel<T>(
      data: data,
    );
  }

  @override
  List<Object?> get props => [];
}

class BaseInitialModel<T> extends BaseState<T> {
  final BaseInitialDataModel<T>? data;

  const BaseInitialModel({this.data});

  T? get model => data?.data;


  @override
  List<Object?> get props => [data];

  BaseInitialModel<T> copyWith({BaseInitialDataModel<T>? data}) {
    return BaseInitialModel<T>(
      data: data ?? this.data,
    );
  }
}

class BaseLoadingModel<T> extends BaseState<T> {
  final BaseLoadingDataModel<T>? data;

  BaseLoadingModel({this.data});

  @override
  List<Object?> get props => [data];

  BaseLoadingModel<T> copyWith({
    BaseLoadingDataModel<T>? data,
  }) =>
      BaseLoadingModel<T>(
        data: data ?? this.data,
      );
}

class BaseErrorModel<T> extends BaseState<T> {
  final BaseErrorDataModel<T>? data;

  BaseErrorModel({this.data});

  @override
  List<Object?> get props => [data];

  BaseErrorModel<T> copyWith({BaseErrorDataModel<T>? data}) => BaseErrorModel<T>(
        data: data ?? this.data,
      );
}

part of 'base_cubit_widget.dart';

final class _StateWidgetBuilder extends StatelessWidget {
  const _StateWidgetBuilder({
    required this.state,
    required this.initial,
    this.error,
    this.loading,
  });

  final BaseState<dynamic> state;
  final InitialBuilder<dynamic> initial;
  final ErrorBuilder<dynamic>? error;
  final LoadingBuilder<dynamic>? loading;

  @override
  Widget build(BuildContext context) {
    switch (state) {
      case BaseInitialModel():
        final initialState = state as BaseInitialModel;

        return initial(initialState);
      case BaseLoadingModel():
        final loadingState = state as BaseLoadingModel;

        return loading != null
            ? loading!(loadingState)
            : const Center(child: CircularProgressIndicator());

      case BaseErrorModel():
        final errorState = state as BaseErrorModel;

        return error != null
            ? error!(errorState)
            : Center(
                child: Text(errorState.data?.message ?? ''),
              );
    }
  }
}

// Splash Model

class SplashModel with EquatableMixin {
  SplashModel({this.message});

  final String? message;

  @override
  List<Object?> get props => [message];

  SplashModel copyWith({String? message}) => SplashModel(
        message: message ?? this.message,
      );
}

I am trying to prepare a base structure for Cubit. I think I did everything right. I see the splashModel object, but I cannot get the variable inside it.