A comprehensive Swift framework for iOS development featuring scene-based architecture, dependency injection, and powerful macro-based code generation.

iOS Core provides a modern, Swift Concurrency-based architecture for iOS apps with:

• Scene-Based Architecture: Manage app flow with Scene protocol and automatic lifecycle management
• Dependency Injection: Type-safe dependency injection with automatic scene association
• Swift Macros: Reduce boilerplate with @Scene, @SceneDependency, and @AsyncInit macros
• Repository Pattern: Clean architecture with local/remote data management
• Redux Integration: State management with Combine-based Redux implementation
• Data Persistence: Core Data and Realm integration

• iOS 13.0+ / tvOS 13.0+ / macOS 10.15+
• Swift 6.2+
• Xcode 15.0+

Add this package to your Package.swift:

dependencies: [ .package(url: "https://github.com/dungntm58/iOSCore.git", from: "1.0.0") ]

Or add it through Xcode: File → Add Package Dependencies and enter the repository URL.

The core of the framework is the Scene protocol, which represents a unit of app functionality:

import CoreMacros import CoreBase @Scene actor LoginScene { @SceneDependency var authService: AuthService @AsyncInit var viewModel = LoginViewModel() func perform(with userInfo: Any?) async { // Scene logic here if await authService.isAuthenticated() { await switch(to: DashboardScene(), with: nil) } } }

Dependencies are automatically resolved and associated with their owning scene:

@SceneDependency class AuthService { func authenticate(username: String, password: String) async -> Bool { // Can access the owning scene through `scene` property return true } }

Views can reference scene dependencies through the @SceneDependencyReference macro:

import SwiftUI import CoreMacros @SceneView struct LoginView: View { @SceneDependencyReference var authService: AuthService? var body: some View { // Use authService here } }

Handle async initialization cleanly with the @AsyncInit macro:

@AsyncInit var expensiveResource = await SomeExpensiveResource.create()

• CoreBase: Scene architecture and base utilities
• CoreMacros: Swift macros for reducing boilerplate
• CoreMacroProtocols: Protocols and types for macro system

• CoreRepository: Repository pattern implementation
• CoreRepositoryLocal: Local data repository support
• CoreRepositoryRemote: Remote API repository support
• CoreRepositoryRequest: HTTP request handling with Alamofire
• CoreDataStore: Core Data integration
• CoreRealmDataStore: Realm database integration

• CoreRedux: Redux pattern with Combine
• CoreReduxList: List-specific Redux utilities

• CoreAPNS: Push notification handling

import CoreMacros import CoreBase @Scene actor WelcomeScene { func perform(with userInfo: Any?) async { print("Welcome scene is active!") // Navigate to next scene after 2 seconds try? await Task.sleep(nanoseconds: 2_000_000_000) await switch(to: LoginScene(), with: nil) } }

import UIKit import CoreBase @UIApplicationMain class AppDelegate: UIResponder, UIApplicationDelegate { var window: UIWindow? private lazy var launcher: Launchable = WelcomeScene() func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool { window = UIWindow(frame: UIScreen.main.bounds) window?.rootViewController = UIViewController() window?.makeKeyAndVisible() Task { @MainActor in await launcher.launch() } return true } }

@SceneDependency class NetworkService { func fetchData() async -> Data? { // Network implementation return nil } } @Scene actor DataScene { @SceneDependency var networkService: NetworkService func perform(with userInfo: Any?) async { let data = await networkService.fetchData() // Process data... } }

If you implement custom scene methods, the macro will provide compiler warnings with instructions:

@Scene actor CustomScene { @SceneDependency var service: MyService // Manual implementation - you'll get a compiler warning to call __setupSceneDependencies() func prepareSelf() async { await __setupSceneDependencies() // Associate dependencies // Your custom preparation logic } }

Scenes can automatically conform to HasViewManagable when they have ViewManager properties:

@Scene actor MyScene { @SceneDependency var viewManager: MyViewManager // ViewManager conforms to ViewManagable // Automatically generates anyViewManager property }

import CoreRepository import CoreRepositoryRemote struct UserRepository: RemoteRepository { typealias Entity = User func fetch(byId id: String) async throws -> User? { // Remote fetch implementation } }

• Generates Scene protocol conformance
• Creates dependency resolution system
• Provides lifecycle method implementations
• Handles ViewManager integration

• Marks types as scene dependencies
• Generates SceneDependency protocol conformance
• Enables automatic scene association

• Used in views to reference scene dependencies
• Generates async getters that resolve through scene
• Validates SceneReferencing conformance

• Handles async property initialization
• Generates Task-based initialization pattern
• Works with both optional and non-optional properties

• Marks views that reference scene dependencies
• Provides SceneReferencing conformance

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests if applicable
5. Submit a pull request

This project is licensed under the MIT License - see the LICENSE file for details.

Robert Nguyen - dungntm58

For more detailed documentation and examples, check out the Example project included in this repository.