rcaos/TVToday

TVToday is an iOS application for browsing and managing TV show information, featuring modules for searching, viewing popular or airing-today lists, and accessing detailed show metadata including seasons and episodes. It supports user authentication and personalization through account management, allowing users to maintain favorites and watchlists. The system relies on a modular architecture with dependency injection, async/await networking, and local persistence via CoreData.

The ShowListDemo application has been added to the main app, providing a demo entry point for the ShowList feature. This includes an AppDelegate that configures the API client using environment-specific keys (API\_KEY, API\_BASE\_URL, IMAGE\_BASE\_URL) from the Info.plist, and a coordinator that initializes the ShowList feature module. The demo app sets up a tab bar with a list scene, pre-configured to navigate to a specific genre list (Documentary, ID 99) using a fake logged-in user repository and an empty detail coordinator for demonstration purposes.

App/Demos/ShowListDemo · high confidence

Introduced \TVShowEpisode\ and \TVShowSeason\ structs in the ShowDetailsFeature domain layer to model TV show data. \TVShowEpisode\ includes properties for ID, episode number, name, air date, vote average, and poster path, along with a computed property to format the vote average as a string. \TVShowSeason\ contains the season ID, number, and an array of associated episodes, providing the necessary data structures for displaying season and episode details.

Sources/ShowDetailsFeature/Domain/Entities · high confidence

The search options screen now includes dedicated UI components for displaying genre filters and recently visited shows. A new GenreTableViewCell presents genre names with proper font sizing and layout constraints, backed by a GenreViewModel. Additionally, a VisitedShowTableViewCell embeds a horizontal collection view to display thumbnails of previously watched shows, allowing users to quickly re-select a show from their history.

Sources/SearchShowsFeature/Presentation/SearchOptions/Cells · high confidence

A new table view cell (HeaderSeasonsTableViewCell) has been introduced to display the show name and a localized season section title. The cell uses auto-layout constraints to position the title and subtitle labels, ensuring the UI correctly reflects localized strings for the season details header.

Sources/ShowDetailsFeature/Presentation/SeasonScene/View/Cells/Header · high confidence

A new \RecentSearchTableViewCell\ is introduced to display recent search queries. The cell presents the search text in a label and includes a system 'arrow.up.left' icon as an accessory, visually indicating that selecting the item will likely navigate back or re-execute the search.

Sources/SearchShowsFeature/Presentation/SearchResults/Cells · high confidence

A new demo application target, SearchShowsDemo, has been added to the project. This demo provides a functional UI for searching TV shows, wired up with a coordinator pattern that initializes the networking client and search feature modules. It includes the necessary iOS asset catalogs, app icon sets, and an Info.plist configured with externalized API keys and base URLs, allowing users to test the search functionality in a standalone app environment.

App/Demos/SearchShowsDemo · high confidence

A new standalone demo application has been added at App/Demos/ShowDetailsDemo to showcase the ShowDetails feature. This demo initializes the app with API configurations from the Info.plist, sets up a tab bar interface, and uses the ShowDetailsFeature module with fake repositories to display a TV show detail screen (specifically Greys Anatomy) upon launch.

App/Demos/ShowDetailsDemo · high confidence

Introduced SwiftGen configuration files to automate the generation of Swift code for localized strings. The new \bin/swiftgen.yml\ file defines the input and output paths for string resources and specifies a custom template (\bin/structured-swift5-custom.stencil\) to generate a typed \Strings\ enum with public access, enabling safer and more convenient access to localized content in the application.

bin · high confidence

A new FooterReusableView component has been introduced within the AiringToday feature's presentation layer. This view extends UICollectionReusableView and automatically displays a loading indicator upon initialization, providing a consistent user experience for loading states in the collection view footer.

Sources/AiringTodayFeature/Presentation/View/Customs · high confidence

Introduced the GenreRemoteDataSource protocol for fetching genre lists and the GenresRepository protocol for exposing genre data within the SearchShowsFeature domain layer, establishing the foundational interfaces for retrieving genre information.

Sources/SearchShowsFeature/Domain/Interfaces · high confidence

This change introduces the data layer support for TV show features by adding new Data Transfer Objects (DTOs) and their corresponding mappers within the network data module. New structs including GenreDTO, TVShowDetailDTO, TVShowPageDTO, TVShowAccountStatusDTO, and TVShowActionStatusDTO define the structure for parsing TV show metadata and user account interactions (favorites, watchlists). To consume these models, the update adds DefaultTVShowDetailsMapper, DefaultTVShowPageMapper, and DefaultAccountTVShowDetailsMapper, which map the raw JSON responses into domain entities, handling image URL construction and genre parsing. These components are wired to new protocols (TVShowPageMapperProtocol, TVShowDetailsMapperProtocol, AccountTVShowsDetailsMapperProtocol) to facilitate dependency injection.

Sources/Shared/Sources/Data/Network · high confidence

New data model structs have been introduced in the persistence layer to support search queries and tracking of visited shows. Specifically, \Search\ and \SearchDLO\ structs now hold search query strings, while \ShowVisited\ and \ShowVisitedDLO\ structs store show identifiers and image paths, providing the underlying data structures for these features.

Sources/Persistence/Entities · high confidence

A new generated Swift file (Strings+Generated.swift) provides type-safe access to localized strings for the app's UI, covering account actions (sign in, sign out, favorites), search functionality (placeholders, recent searches, genres), and content sections (popular, airing today, seasons). This enables compile-time safety for string keys used in the interface.

Sources/UI/Generated · high confidence

Users can now retrieve the list of TV show genres via the SearchShowsFeature. This change introduces a new remote data source that fetches genre data from the API endpoint '3/genre/tv/list', maps the response into a structured GenreList, and exposes it through the GenresRepository for use within the feature.

Sources/SearchShowsFeature/Data · high confidence

The domain layer now includes a concrete use case, DefaultFetchPopularTVShowsUseCase, which implements the FetchTVShowsUseCase protocol. This component injects a TVShowsPageRepository to fetch popular TV show pages, establishing the specific data retrieval logic for this feature within the domain layer.

Sources/PopularsFeature/Domain · high confidence

This change introduces the core UI components for the TV Show Details feature, including the root view and view controller. Users will now see a scrollable layout displaying the show's backdrop image, title, release year, duration, genre, and an episode guide section. The screen also supports dynamic type sizing for better accessibility and includes navigation bar buttons for adding the show to favorites or a watchlist, which update their appearance based on the user's logged-in status and current selection state.

Sources/ShowDetailsFeature/Presentation/ShowDetailsScene/View · high confidence

The UI module now includes its own dedicated resource bundle, containing English and Spanish localizable strings for core screens (Airing Today, Popular, Search, Account) and a new Assets catalog with specific imagesets like account.tv, loginbackground, and various error/placeholder graphics. This establishes the foundation for displaying localized text and consistent visual assets within the UI layer, replacing or supplementing previous shared resources.

Sources/UI/Resources · high confidence

Added the DIContainer module for the Account feature, which wires up repositories (Auth, Account, Logged User) and use cases (Create Session, Fetch Account Details, Fetch Logged User, Delete Logged User) to the AccountViewModel and Coordinator. This enables the Account feature to build its view controllers and navigate to authentication, favorites, and watchlist screens using the provided dependencies.

Sources/AccountFeature/DIContainer · high confidence

Adds the Airing Today feature module, providing the entry point to build its coordinator and wire up dependencies. The module defines the navigation flow for displaying today's shows and transitioning to show details, utilizing a DI container to inject the API client, image base URL, and the Show Details feature builder.

Sources/AiringTodayFeature/DIContainer · high confidence

The application now includes a new local data storage implementation using CoreData. This change adds a shared CoreDataStorage singleton to manage the persistent container and a LocalStorage class that acts as a factory for local data sources, specifically providing access to shows visited history and recent search queries via the PersistenceStore abstraction.

Sources/PersistenceLive/Public · high confidence

Added the \PopularViewModel\ and its protocol to handle the presentation logic for the popular TV shows feature. This component manages fetching paginated TV show data via \FetchTVShowsUseCase\, processes the results to ensure uniqueness by ID, maps entities to view models for the UI, and exposes state changes (loading, empty, error, paging, populated) through an observable subject. It also handles user interactions such as row selection for navigation and pull-to-refresh functionality.

Sources/PopularsFeature/Presentation/ViewModel · high confidence

Added the ProfileViewModel and supporting model types (ProfileSectionModel, ProfilesSectionItem, UserListType) to structure the account profile UI. The ViewModel exposes a data source for profile sections (user info, user lists like favorites and watchlist, and logout) and handles user interactions such as tapping logout or navigating to user lists via a delegate.

Sources/AccountFeature/Presentation/Profile/ViewModel · high confidence

Added a new SearchOptionsViewModel that manages the state and data source for the search options interface. The view model fetches available genres and recently visited shows, exposing them via a reactive data source that updates the UI. It supports selecting a genre to trigger a search or picking a recent show to view its details, while handling loading, empty, and error states for the options list.

Sources/SearchShowsFeature/Presentation/SearchOptions/ViewModel · high confidence

This change introduces the Search Shows feature module, providing the entry point for users to search for TV shows. It establishes the dependency injection container (DIContainer) to wire up use cases for searching shows, fetching recent searches, genres, and visited shows, along with their respective view models and view controllers. A SearchCoordinator manages the navigation flow, handling transitions from the main search screen to genre lists and show details, while integrating with existing Show Details and Show List modules.

Sources/SearchShowsFeature/DIContainer · high confidence

The ShowDetailsFeatureInterface module has been added to define the public API for the show details feature. It introduces the ModuleDependencies struct to inject required services (API client, image base URL, and persistence repositories), along with protocols for the module builder (ModuleShowDetailsBuilder) and coordinator (TVShowDetailCoordinatorProtocol). The module also defines the navigation steps (ShowDetailsStep) and closure types (TVShowDetailViewModelClosures) used to handle user interactions such as updating favorites or watchlists.

Sources/ShowDetailsFeatureInterface · high confidence

The ShowDetailsFeature now defines the domain interface for fetching TV show episodes via the new TVEpisodesRepository protocol. This change establishes the contract for retrieving season data (TVEpisodesRemoteDataSource) and mapping remote DTOs to domain models (TVEpisodesMapperProtocol), laying the groundwork for the underlying implementation.

Sources/ShowDetailsFeature/Domain/Interfaces · high confidence

Added the \TVShowDetailInfo\ struct to represent TV show metadata and the \TVShowDetailViewModel\ to manage the show details screen. The view model handles fetching show details and account states (favorites, watchlist) for both logged-in and guest users, and manages user interactions for marking a show as a favorite or adding it to the watch list with optimistic UI updates.

Sources/ShowDetailsFeature/Presentation/ShowDetailsScene/ViewModel · high confidence

This change adds the presentation-layer ViewModels and section models for the Show Details feature's season/episode scene. It introduces \EpisodesListViewModel\ to manage fetching show details and episodes, handling loading states, and exposing data via Combine streams. Supporting ViewModels (\SeasonListViewModel\, \SeasonEpisodeViewModel\, \SeasonHeaderViewModel\, \EpisodeItemViewModel\) and section model types (\SeasonsSectionModel\, \EpisodeSectionModelType\) are added to structure the UI data for seasons, episodes, and show headers, enabling the view layer to bind to this structured data.

Sources/ShowDetailsFeature/Presentation/SeasonScene/ViewModel · high confidence

The SearchShowsFeature domain layer now includes specific use cases for retrieving genre lists and searching TV shows. FetchGenresUseCase provides a direct path to fetch genres via the GenresRepository, while SearchTVShowsUseCase handles TV show searches, including logic to save the search query to local storage when fetching the first page of results.

Sources/SearchShowsFeature/Domain/UseCases · high confidence

The Popular Shows feature now uses a dedicated DI container to assemble its navigation and data layers. This change introduces a \Module\ entry point and a \DIContainer\ that wires the \PopularCoordinator\ with the \PopularViewModel\, \FetchTVShowsUseCase\, and \DefaultTVShowsPageRepository\. It also establishes the navigation flow from the popular list to the show detail screen by injecting the \ShowDetailsFeatureInterface\ builder, ensuring the feature is fully decoupled and ready for integration.

Sources/PopularsFeature/DIContainer · high confidence

This change adds new interface definitions and repository implementations for local data handling. Specifically, it introduces \SearchLocalDataSource\ and \SearchLocalRepository\ protocols and classes to manage saving search queries and fetching recent searches, abstracting the current user ID via \LoggedUserRepositoryProtocol\. Similarly, it adds \ShowsVisitedLocalDataSource\ and \ShowsVisitedLocalRepository\ to handle saving visited shows, fetching the list of visited shows, and observing changes via \AsyncStream\. A mock implementation (\FakeShowsVisitedLocalRepository\) is also provided for testing purposes.

Sources/Persistence/Interfaces · high confidence

Added the presentation layer for the Populars feature, including \PopularsRootView\ and \PopularsViewController\. The list uses a \UITableViewDiffableDataSource\ for state-driven updates, automatic row dimensions, and handles loading, empty, error, and paging states via a refresh control and footer views.

Sources/PopularsFeature/Presentation/View · high confidence

The search results interface now uses a dedicated view hierarchy featuring a sectioned table view that distinguishes between recent searches and search results. Users will see a localized header for the 'Recent Searches' section, while other sections remain headerless. The view handles various states including loading, empty results, and errors, displaying appropriate messages or indicators at the bottom of the list. Selection of a recent search query or a show result triggers the corresponding action in the view model.

Sources/SearchShowsFeature/Presentation/SearchResults/View · high confidence

The app now includes a dedicated search screen that allows users to input text queries, select genres, or pick from recent shows to find TV content. This feature adds the necessary view controller and view model to handle search input, bind the UI state, and coordinate navigation to show details or filtered results.

Sources/SearchShowsFeature/Presentation/Search · high confidence

The search options interface now displays two distinct sections: recently visited shows and available genres. This change implements the view layer using a diffable data source to manage the table view, supporting states for loading, populated content, empty results, and errors. Users can now interact with these sections to filter or navigate their search based on their viewing history or preferred genres.

Sources/SearchShowsFeature/Presentation/SearchOptions/View · high confidence

The search results screen now uses a dedicated view model that manages search state (initial, loading, empty, populated, error) and data sources via Combine subjects. Users benefit from immediate feedback during searches, display of recent search history, and robust error handling that surfaces error messages directly in the UI.

Sources/SearchShowsFeature/Presentation/SearchResults/ViewModel · high confidence

Added two new presentation components for the Show Details feature: SeasonEpisodeCollectionViewCell, which displays a circular label for the season number that highlights in yellow when selected, and SeasonListTableViewCell, which hosts a horizontal collection view of these cells. The list cell binds to a view model to display available seasons and handles user selection to trigger navigation or state changes.

Sources/ShowDetailsFeature/Presentation/SeasonScene/View/Cells/SeasonEpisodeList · high confidence

This change introduces a new set of public domain entities in the shared Sources/Shared/Sources/Domain/Entities module to model TV show data and user account interactions. Key additions include TVShowPage for paginated lists of shows, TVShowDetail for comprehensive show metadata (including computed release years and episode duration), and TVShowAccountStatus to track user-specific states like favorites and watchlists. The existing Genre struct has been moved from the MyMovies/Responses folder to this shared domain layer, made public, and updated to conform to Hashable, enabling its use across different parts of the application. These entities provide a unified, public-facing data model for TV show information and user account status.

Sources/Shared/Sources/Domain/Entities · high confidence

Adds the \ModuleInterface.swift\ file which defines the public API for the ShowList feature. This includes the \ModuleDependencies\ struct for dependency injection (providing API client, image base URL, user repository, and show details builder), coordinator protocols (\TVShowListCoordinatorProtocol\, \ModuleShowListDetailsBuilder\), and navigation step definitions (\TVShowListStep\) for navigating to genre lists, favorites, watchlists, and specific show details.

Sources/ShowListFeatureInterface · high confidence

Added new domain model structs for the account feature, including Account (with id, userName, and avatarURL), NewRequestToken, and NewSession. These entities define the core data structures for user accounts and session handling within the application's domain layer.

Sources/AccountFeature/Domain/Entities · high confidence

A new standalone demo application for the Account feature has been added under App/Demos/AccountDemo. It provides a complete iOS app structure (AppDelegate, Coordinator, Info.plist) that initializes the AccountFeature module using a live ApiClient. The app reads API configuration (base URLs, API key, Gravatar URL) from the Info.plist at runtime, allowing users to test the Account feature against a real backend by simply providing the necessary environment variables in the bundle.

App/Demos/AccountDemo · high confidence

A new standalone demo app for the Airing Today feature has been added. It provides a complete iOS application entry point (AppDelegate) that configures the API client using environment variables for the base URL, API key, and image base URL. The app initializes a TodayDemoCoordinator to present the Airing Today module within a tab bar interface, including a placeholder implementation for the show details navigation.

App/Demos/AiringTodayDemo · high confidence

A new standalone demo application (PopularDemo) has been added to the project, providing a concrete entry point for testing the Populars feature. This demo app initializes a tab-based interface displaying the popular content list, wired up with a dedicated coordinator that injects the networking client and image base URL. It also includes a placeholder implementation for the show details view, allowing users to verify the integration of the Populars feature module within a full app lifecycle.

App/Demos/PopularDemo · high confidence

This change introduces a new set of data source protocols and implementations for TV show data. It includes local data sources for managing access tokens, request tokens, and logged-in user information. Remote data sources are added for fetching TV show details, popular shows, airing today shows, shows by genre, and search results. Additionally, account-specific remote data sources are introduced to handle fetching favorite and watchlist TV shows, as well as marking shows as favorites or adding them to the watchlist.

Sources/Shared/Sources/Data/DataSources · high confidence

This change introduces a new set of reusable UI components and protocols within the UI module, shifting the codebase away from nib-based instantiation. It adds specific views for common states: \EmptyView\ and \ErrorView\ (with retry logic) for content states, \LoadingView\ and \LoadableButton\ for activity indicators, and \MessageView\/\MessageImageView\ for user feedback. It also introduces \GenericViewCell\ and \TVShowViewCell\ for list items, with the latter supporting dynamic type sizing and displaying poster images, names, dates, and ratings. To enforce this new programmatic approach, new protocols (\NiblessView\, \NiblessTableViewCell\, \NiblessCollectionViewCell\, \NiblessViewController\) are added to prevent loading views from nibs, while \Emptiable\, \Loadable\, and \Retryable\ protocols provide standard extensions for ViewControllers to manage these states.

Sources/UI/Components · high confidence

This change introduces a suite of new Swift extensions in the UI module to streamline common interface patterns. Navigation controllers can now apply a standardized appearance with blue, rounded-bold titles via \replaceAppearance()\. Table and collection views gain type-safe \registerCell\ and \dequeueReusableCell\ methods that automatically derive reuse identifiers from the cell type, reducing boilerplate. Additional helpers include \pin\ for view anchoring, \endRefreshing\ with a delay for pull-to-refresh controls, child view controller management utilities, and font modifiers for bold, italic, and weighted text styles.

Sources/UI/Extensions · high confidence

The application introduces a set of new repository implementations to handle data access for authentication flows and TV show content. Authentication capabilities are now supported by AccessTokenRepository, RequestTokenRepository, and LoggedUserRepository, which manage local storage of tokens and user session details. Content retrieval is handled by DefaultTVShowsPageRepository (providing methods for popular, airing today, genre-based, and search queries), DefaultTVShowsDetailRepository (for individual show details), DefaultAccountTVShowsRepository (for user-specific favorite and watchlist lists), and DefaultAccountTVShowsDetailsRepository (for marking favorites and watchlist status). These components rely on injected data sources and mappers to fetch and transform network data.

Sources/Shared/Sources/Data/Repositories · high confidence

The episode list now uses a new \EpisodeItemTableViewCell\ to display individual episodes. This cell presents the episode number and name, release date, and a star-based average rating alongside a poster image. The layout uses Auto Layout to position the image on the left and text details on the right, with a separator line at the top. Crucially, the labels are configured with \adjustsFontForContentSizeCategory = true\, ensuring that text scales appropriately when users change their system's dynamic type settings.

Sources/ShowDetailsFeature/Presentation/SeasonScene/View/Cells/EpisodesList · high confidence

The Show Details feature now includes a new EpisodesListViewController and its associated root view to display season and episode information. This view uses a UITableViewDiffableDataSource to render sections for the show header, season list, and individual episodes, with automatic row height calculation for most items and a fixed height for the season section. It handles various view states (loading, populated, empty, error) by displaying appropriate feedback views, such as a loading spinner or error message with a retry option, ensuring users see the correct content or status for the selected show's episodes.

Sources/ShowDetailsFeature/Presentation/SeasonScene/View · high confidence

The profile screen now uses dedicated table view cells for displaying user information and the logout action. The new ProfileTableViewCell presents a greeting with the user's name and their avatar image, while the LogoutTableViewCell displays a centered, red logout label. Both cells inherit from a common base class to ensure consistent styling and behavior within the account feature.

Sources/AccountFeature/Presentation/Profile/View/Cells · high confidence

The profile view now uses a UITableView with automatic dimension cells to support dynamic heights, displaying user info, localized list items, and a logout option. The logout action presents a localized confirmation alert via an action sheet, with all UI strings localized for the user's language.

Sources/AccountFeature/Presentation/Profile/View · high confidence

Added FetchLoggedUser and FetchTVShowsUseCase to the domain layer, enabling the application to retrieve the current user's account details and a paginated list of TV shows respectively.

Sources/Shared/Sources/Domain/UseCases · high confidence

The domain layer now includes three new use cases that enable fetching specific sets of TV shows: user favorites, the user's watchlist, and shows filtered by genre. These use cases conform to the FetchTVShowsUseCase protocol and delegate to the appropriate repositories (AccountTVShowsRepository for favorites and watchlist, TVShowsPageRepository for genre-based fetching), allowing the UI to retrieve these distinct lists via a unified interface.

Sources/ShowListFeature/Domain · high confidence

The app now includes a shared module providing core infrastructure components: a Coordinator protocol for managing navigation flows, a Language enum to handle supported app locales (English and Spanish), and a generic SimpleViewState enum to manage UI states such as loading, paging, populated, empty, and error conditions for list-based views.

Sources/Shared/Sources · high confidence

The Show Details feature has been updated to include a new screen for browsing seasons and episodes. Users can now navigate from the main show details view to a dedicated list of episodes, which is built using a new \EpisodesListViewController\ and \EpisodesListViewModel\. This change introduces new dependencies for fetching episode data and managing the navigation flow between the show details and the seasons list.

Sources/ShowDetailsFeature/DIContainer · high confidence

The ShowDetailsFeature now includes the data layer for retrieving TV show episode information. This adds a remote data source that fetches season details from the API endpoint '3/tv/{showId}/season/{season}', along with DTOs for parsing season and episode data, and a mapper that converts these network responses into domain models with constructed image URLs.

Sources/ShowDetailsFeature/Data · high confidence

The Xcode project file (project.pbxproj) for the MyMovies application has been deleted. This removes the build configuration, source file references (including view controllers, models, and assets), and target definitions for the app from the repository.

MyMovies.xcodeproj · high confidence

This change removes the source files for the 'Airing Today', 'Popular Shows', and 'Search' screens, along with their associated view controllers, table view cells, and the global \Model\ singleton that previously held in-memory state for these lists. It also deletes the \TVShow\, \TVShowDetail\, and \TVShowResult\ response models and the \TMDBClient\ networking layer. This cleanup eliminates the old table-view-based navigation and data-fetching logic, preparing the codebase for the new UseCase-based architecture and search controller mentioned in the commit history.

MyMovies · high confidence

The app's startup flow and navigation architecture have been refactored to use a centralized dependency injection container. AppFeature now defines an AppConfigurationProtocol for external settings (API keys, base URLs) and an AppDIContainer that wires up networking, local storage, and repositories. AppCoordinator initializes the main window with a UITabBarController, and SignedCoordinator manages the four main tabs (Airing Today, Popular, Search, Account) by building their respective modules through the DI container, replacing previous direct instantiation or loose coupling patterns.

Sources/AppFeature · high confidence

The Show List feature now uses a dedicated dependency injection container and coordinator to manage its lifecycle and navigation. This change centralizes the construction of view controllers for genre lists, favorites, and watchlists, and handles navigation to the show detail screen, replacing the previous implicit or scattered wiring with a structured, testable module entry point.

Sources/ShowListFeature/DIContainer · high confidence

The account feature's network data layer has been reorganized to separate data transfer objects (DTOs) from domain models and mapping logic. New DTO structs (AccountDTO, AvatarDTO, GravatarDTO, NewRequestTokenDTO, NewSessionDTO) are now defined in a dedicated DataMapping directory to handle JSON decoding, while a new RequestTokenMapper converts these DTOs into domain models (NewRequestToken), centralizing the transformation logic previously implied to be elsewhere.

Sources/AccountFeature/Data/Network · high confidence

The domain interfaces for account and authentication features have been restructured to separate concerns between high-level repositories and low-level data sources. New protocols have been introduced: \AccountRepository\ and \AuthRepository\ define the public API for fetching account details and managing authentication sessions (requesting tokens and creating sessions), while \AccountRemoteDataSource\ and \AuthRemoteDataSource\ handle the underlying asynchronous data retrieval. This change decouples the domain logic from the specific data fetching mechanisms, allowing for easier implementation of different data sources or mocking in tests.

Sources/AccountFeature/Domain/Interfaces · high confidence

The Xcode project has been restructured to include multiple independent demo applications (ShowListDemo, PopularDemo, SearchShowsDemo, AccountDemo, ShowDetailsDemo, AiringTodayDemo) alongside the main TVToday app. Each demo target is configured to link against specific feature frameworks (e.g., ShowListFeature, PopularsFeature, SearchShowsFeature) and includes its own coordinator classes (e.g., TodayDemoCoordinator, PopularDemoCoordinator) to manage navigation within that specific feature context. This change allows developers to build and run isolated demos for individual features rather than only the full application.

App/TVToday.xcodeproj · high confidence

The AccountViewController has been updated to create its child view controllers (Sign In and Profile) asynchronously via the AccountViewControllerFactory. This change allows the factory methods to perform asynchronous operations during instantiation, ensuring that the UI setup is properly awaited before transitioning to the new child view controller.

Sources/AccountFeature/Presentation/Account/View · high confidence

The Airing Today feature now renders its list of shows using a UICollectionViewCompositionalLayout instead of the previous custom flow layout. This change provides a more robust and standard layout engine for the collection view, ensuring consistent item sizing and spacing. Additionally, the implementation now properly triggers the \willDisplayRow\ method on the view model when cells appear on screen, enabling reliable infinite scrolling and pagination behavior for users as they browse the list.

Sources/AiringTodayFeature/Presentation/View · high confidence

The AuthPermission presentation layer has been refactored to use Swift's async/await concurrency model. The view controller and root view now trigger asynchronous sign-in actions via Tasks when the authentication callback is detected or the presentation is dismissed, and the view model communicates the sign-in completion to its delegate using an async method.

Sources/AccountFeature/Presentation/AuthPermission · high confidence

Added Xcode scheme files for the Account, AiringToday, App, Networking, Populars, SearchShows, ShowDetails, ShowDetailsTests, and ShowList features. These schemes configure the build and test actions for each module, explicitly linking their respective test targets (e.g., AccountFeatureTests, ShowDetailsFeatureTests) and pre-configuring skipped tests for UI components like AccountView, SignInView, and TVShowDetailView to ensure stable test execution.

.swiftpm · high confidence

The sign-in view model now uses an async method for the sign-in action, allowing the UI to remain responsive while the token creation process completes. View state changes (initial, loading, error) are exposed via a Published publisher, enabling the interface to reactively update as the user progresses through the authentication flow.

Sources/AccountFeature/Presentation/SignIn/ViewModel · high confidence

The Airing Today feature now uses a new \AiringTodayViewModel\ that handles data fetching and UI state updates asynchronously. This change replaces the previous synchronous approach, allowing the list to load shows and handle pagination (loading the next page when the user scrolls to the bottom) without blocking the main thread. The view model exposes its state via a Combine subject, enabling the UI to react to loading, empty, error, and populated states in real time.

Sources/AiringTodayFeature/Presentation/ViewModel · high confidence

The networking layer has been replaced with a new architecture that uses Swift's async/await concurrency model. This change introduces a public \ApiClient\ interface in \Sources/NetworkingInterface\ that exposes asynchronous \apiRequest\ methods for performing network calls and decoding responses, along with supporting types like \Endpoint\, \NetworkConfig\, and \ApiError\. The concrete implementation in \Sources/Networking\ (\ApiClient+Live\) now utilizes \URLSession\'s async capabilities to execute requests, while also providing a \NetworkLogger\ for debugging request and response data in development builds.

Sources/NetworkingInterface · high confidence

The KeyChainStorage module now uses a new \KeychainItemStorage\ property wrapper backed by \KeychainSwift\ to manage sensitive data. This allows \DefaultKeyChainStorage\ to store and retrieve authentication tokens and user account details (request token, access token, account ID, session ID) with cleaner, declarative code, replacing previous implementation details.

Sources/KeyChainStorage · high confidence

A new ErrorEnvelope struct has been added to the Domain layer to standardize error representation, containing an array of error messages and an optional API code. This type conforms to the Error protocol and includes a TodayCode enum for specific client-defined codes like mapping failures and transfer errors, though a warning suggests ApiError may be the preferred alternative in the future.

Sources/Shared/Sources/Domain · high confidence

The AccountViewModel has been introduced to manage the account feature's presentation logic, adopting an asynchronous approach for data fetching and session management. It utilizes Swift's @Published property wrapper to expose the view state (login or profile) to the UI, ensuring reactive updates. The view model now handles user authentication flows, including checking login status, fetching account details, creating sessions, and logging out, all coordinated through async/await patterns and dependency injection for use cases.

Sources/AccountFeature/Presentation/Account/ViewModel · high confidence

The UI/Localized module now includes a new file, Strings+localized.swift, which provides the core logic for resolving localized strings. This change introduces a public function, localizeKey, that accepts a string key and a locale, and returns the corresponding localized string by locating the appropriate .lproj bundle for the specified language. The implementation handles cases where a bundle cannot be found by returning an empty string and maps locale codes to language-specific bundle names using a Language enum from the Shared module.

Sources/UI/Localized · high confidence

The iOS app now centralizes external service URLs (TMDB API, authentication, Gravatar) and the API key in a new Config.xcconfig file, with corresponding entries added to Info.plist to inject these values at build time. The app bundle identifier has been updated to home.rcaos.tvtoday, and the main storyboard reference in Info.plist has been cleared, indicating a shift away from the previous Main.storyboard-based UI initialization.

App/iOS · high confidence

The internal persistence implementation in the PersistenceLive module has been migrated to use CoreData, introducing new entities for recent searches (CDRecentSearch) and visited shows (CDShowVisited). This change adds a configurable storage limit for visited shows, automatically deleting older records when the limit is exceeded, and replaces the previous notification mechanism with an AsyncStream to signal when visited show data changes.

Sources/PersistenceLive/Internal · high confidence

The persistence use cases for fetching recent searches, fetching visited shows, and observing changes to recent visited shows have been updated to use modern concurrency primitives. Fetching recent searches now returns an async result instead of using Combine, and the observer for recent visited show changes now emits an AsyncStream. This allows callers to handle these persistence operations using Swift's native async/await patterns rather than reactive streams.

Sources/Persistence/UseCases · high confidence

The TVShowDetail scene has been extracted from Main.storyboard into its own dedicated storyboard file. This change decouples the detail view's layout and navigation from the main application entry point, simplifying the primary storyboard and isolating the detail view's UI components (such as the StackViews and AutoLayout constraints for the show poster, title, and description) for easier maintenance.

MyMovies/Base.lproj · high confidence

The sign-in screen now uses a custom view hierarchy featuring a localized button (displaying the text from Strings.accountTitleDetailButton) and a TV logo image. The interface supports visual loading states, showing a spinner on the button during sign-in attempts and hiding it upon completion or error.

Sources/AccountFeature/Presentation/SignIn/View · high confidence

The Xcode project has been renamed from MyMovies to TVToday, updating the workspace references and adding dedicated launch schemes for the main app, AccountDemo, and AiringTodayDemo. The main TVToday scheme now includes disabled command-line arguments to enable CoreData SQL and concurrency debugging, facilitating easier troubleshooting of data stack issues during development.

App/TVToday.xcodeproj/xcshareddata · high confidence

The Airing Today collection view cell has been rewritten to use UIStackViews for the show name and average rating sections, replacing the previous manual layout approach. This change introduces support for dynamic type via \adjustsFontForContentSizeCategory\ on the show name label, ensuring text scales correctly with system settings. The visual layout now features a background poster image with a rounded container, displaying the show name and a star icon alongside the average rating in a horizontal stack.

Sources/AiringTodayFeature/Presentation/View/Cells · high confidence

The account feature's use cases (CreateSession, CreateToken, DeleteLoggedUser, FetchAccountDetails) have been rewritten to adopt Swift's async/await concurrency model and now delegate directly to their respective repositories (AuthRepository, LoggedUserRepositoryProtocol, AccountRepository) instead of handling low-level details like keychain or networking internally. This change simplifies the use case logic, making them thin coordinators that rely on injected dependencies for data access, and updates the return types to match the asynchronous nature of the underlying repository calls.

Sources/AccountFeature/Domain/UseCases · high confidence

The use cases in the Show Details feature (FetchEpisodes, FetchTVAccountStates, FetchTVShowDetails, MarkAsFavorite, SaveToWatchList) have been rewritten to depend on new repository protocols (TVEpisodesRepository, AccountTVShowsDetailsRepository, TVShowsDetailsRepository, ShowsVisitedLocalRepositoryProtocol) instead of previous implementations. This changes how data is fetched and persisted within the feature, aligning the domain layer with the updated repository contracts.

Sources/ShowDetailsFeature/Domain/UseCases · high confidence

The account and authentication data access logic has been restructured into distinct repository and remote data source components. The new DefaultAccountRepository now retrieves account details by fetching an access token from a dedicated repository, saving the logged-in user's information, and mapping the avatar URL using a configurable base URL. Similarly, the DefaultAuthRepository manages the authentication flow by requesting tokens, persisting them, and creating sessions, ensuring that access tokens are saved upon successful session creation. These changes separate concerns between network requests (handled by remote data sources) and business logic/persistence (handled by repositories).

Sources/AccountFeature/Data/Repositories · high confidence

The domain layer's repository contracts have been reorganized to separate concerns between user authentication and content retrieval. New protocols have been introduced for managing access tokens (\AccessTokenRepositoryProtocol\), request tokens (\RequestTokenRepositoryProtocol\), and logged-in user state (\LoggedUserRepositoryProtocol\). For TV show data, the interfaces are now split into specific repositories: \AccountTVShowsRepository\ and \AccountTVShowsDetailsRepository\ handle user-specific actions like favorites and watchlists, while \TVShowsPageRepository\ and \TVShowsDetailsRepository\ manage public content fetching, including support for fetching shows by genre.

Sources/Shared/Sources/Domain/Interfaces · high confidence

The genre domain entity has been moved from the MyMovies responses layer to the SearchShowsFeature domain entities and renamed to GenreList. This change updates the struct to be immutable (using let instead of var) and removes the Codable conformance, aligning the domain model with the new feature's requirements.

Sources/SearchShowsFeature/Domain/Entities · high confidence

The TV show list presentation layer has been refactored to use a \UITableViewDiffableDataSource\ for managing list updates, replacing the previous implementation. This change introduces automatic pagination: the list now detects when the user scrolls near the end of the content via \willDisplay\ and requests more data from the view model, rather than relying on a fixed-height row calculation or manual scroll offset checks. The view controller also handles state-based UI updates for loading, empty, and error states.

Sources/ShowListFeature/Presentation/View · high confidence

The TV show list now uses infinite scroll pagination triggered by the \willDisplayRow\ event, automatically fetching the next page of results when the user reaches the bottom of the list. Selecting a show passes its index to the coordinator for navigation, and the list state updates to reflect loading, empty, error, or populated conditions based on the fetched data.

Sources/ShowListFeature/Presentation/ViewModel · high confidence

The FetchAiringTodayTVShowsUseCase implementation has been updated to depend on TVShowsPageRepository instead of its previous data source. This change means the use case now retrieves airing today TV shows through a page-oriented repository interface, aligning the domain logic with the new repository abstraction.

Sources/AiringTodayFeature/Domain · high confidence

Added mock implementations for PopularsFeature tests; Added mock implementations for SignInViewModel tests; Added mock implementations for account use cases; Added mock implementations for search view model and use cases; Added mock view models for account feature tests; Added snapshot tests for AiringTodayView states; Added snapshot tests for EpisodesListViewController; Added snapshot tests for SearchOptionsViewController; Added snapshot tests for TVShowDetailView; Added snapshot tests for TVShowListView states; Added snapshot tests for search results view states; Added stub for Account entity in unit tests; Added test mocks and builders for ShowListFeature; Added test mocks and stubs for Search Shows feature; Added test mocks and stubs for ShowDetails and Seasons scenes; Added test mocks for AiringToday feature; Added test plan configuration for AppFeatureTests; Added test utilities for TV show data mocking; Added tests to detect missing or duplicate localization keys; Added unit and snapshot tests for Account feature presentation layer; Added unit and snapshot tests for the Populars feature presentation layer; Added unit and snapshot tests for the Sign In feature; Added unit tests for AiringTodayViewModel; Added unit tests for ApiClient networking behavior; Added unit tests for EpisodesListViewModel; Added unit tests for ProfileViewModel; Added unit tests for SearchOptionsViewModel; Added unit tests for TVShowDetailViewModel; Added unit tests for TVShowListViewModel state transitions; Added unit tests for the search results view model.

The project now uses Swift Package Manager (SPM) to manage its structure and dependencies. The root Package.swift defines the TVToday app targeting iOS 14 and Swift 5.9, organizing the code into modular libraries such as AppFeature, AccountFeature, Networking, Persistence, and UI. It introduces external dependencies for keychain storage (keychain-swift), image caching (Kingfisher), and testing utilities (swift-snapshot-testing, swift-concurrency-extras, swift-algorithms, swift-custom-dump). Empty placeholder packages are also added for App, Screenshots, and bin directories to support Xcode project integration.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 50.

• Code Health 71
• Architecture 91
• Maturity 65
• Readiness 25
• Security 65
• Domain Modelling 100
• Performance 100

• 300 commits — 260 feature/other, 40 fixes

• Sources/AccountFeature — 34 commits
• (root) — 33 commits
• Sources/UI — 29 commits
• Sources/AiringTodayFeature — 28 commits
• Sources/ShowDetailsFeature — 21 commits
• App/Demos — 16 commits
• Sources/SearchShowsFeature — 15 commits
• Sources/Shared — 15 commits
• Tests/AccountFeatureTests — 12 commits
• Tests/SearchShowsFeatureTests — 11 commits
• Sources/ShowListFeature — 9 commits
• Tests/ShowDetailsFeatureTests — 9 commits
• (repo) — 8 commits
• Sources/PopularsFeature — 7 commits
• Tests/ShowListFeatureTests — 6 commits
• App/TVToday.xcodeproj — 5 commits
• Sources/AppFeature — 5 commits
• Sources/Persistence — 5 commits
• Tests/PopularsFeatureTests — 5 commits
• Tests/AiringTodayFeatureTests — 4 commits

• fix: Avoid fix height
• fix: Avoid fix height on row
• fix: Change fixed strings by enum
• fix: Change fixed strings by localizable keys
• fix: Fix Account module inject new attribute
• fix: Fix ViewModels tests
• fix: Fix account demo, inject new attribute
• fix: Fix center on cell
• fix: Fix constraints
• fix: Fix constraints on Genre cell
• fix: Fix image alignment
• fix: Fix keys
• fix: Fix leading space
• fix: Fix mocks and stubs
• fix: Fix mocks and stubs
• fix: Fix only call activate constraints once
• fix: Fix row height on header table view
• fix: Fix separator on localizable strings
• fix: Fix sinopsis row height
• fix: Fix tests
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

rcaos/TVToday was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.