Merge branch 'main' of https://github.com/Coder-ACJHP/VideoEditor

Author: Coder-ACJHP

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.github/workflows/swift.yml

@@ -0,0 +1,63 @@
+name: iOS Build
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  build:
+    name: Build (Simulator)
+    runs-on: macos-latest
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v5
+
+      - name: Select Xcode
+        uses: maxim-lobanov/setup-xcode@v1
+        with:
+          xcode-version: latest-stable
+
+      - name: Resolve Xcode project and verify scheme
+        run: |
+          set -euo pipefail
+          ROOT="$GITHUB_WORKSPACE"
+          PROJ="$ROOT/VideoEditor.xcodeproj"
+          if [[ ! -f "$PROJ/project.pbxproj" ]]; then
+            PROJ=$(find "$ROOT" -name "VideoEditor.xcodeproj" -type d 2>/dev/null | head -1 || true)
+          fi
+          if [[ -z "${PROJ:-}" ]] || [[ ! -f "$PROJ/project.pbxproj" ]]; then
+            echo "::error::VideoEditor.xcodeproj not found under $ROOT"
+            echo "Discovered .xcodeproj paths (max depth 8):"
+            find "$ROOT" -maxdepth 8 -name "*.xcodeproj" -type d 2>/dev/null || true
+            echo "Repository root listing:"
+            ls -la "$ROOT"
+            exit 1
+          fi
+          echo "Using Xcode project: $PROJ"
+          echo "XCODEPROJ=$PROJ" >> "$GITHUB_ENV"
+          SCHEME_FILE="$PROJ/xcshareddata/xcschemes/VideoEditor.xcscheme"
+          if [[ ! -f "$SCHEME_FILE" ]]; then
+            echo "::error::Shared scheme missing: $SCHEME_FILE"
+            echo "In Xcode: Product → Scheme → Manage Schemes → enable Shared for VideoEditor, then commit xcshareddata/xcschemes/."
+            exit 1
+          fi
+          xcodebuild -list -project "$PROJ"
+
+      - name: Build
+        run: |
+          set -euo pipefail
+          DERIVED_DATA="$RUNNER_TEMP/DerivedData-VideoEditor"
+          mkdir -p "$DERIVED_DATA"
+          xcodebuild \
+            -project "$XCODEPROJ" \
+            -scheme VideoEditor \
+            -configuration Debug \
+            -destination 'generic/platform=iOS Simulator' \
+            -derivedDataPath "$DERIVED_DATA" \
+            build

.gitignore

@@ -0,0 +1 @@
+.DS_Store

App/AppDelegate.swift

@@ -0,0 +1,59 @@
+//
+// AppDelegate
+// VideoEditor
+//  Created by Coder ACJHP on 27.03.2026.
+
+
+import UIKit
+import CoreData
+
+/// Entry point for the process (`@main`). Owns the Core Data stack; UI flows are driven by `SceneDelegate` and scene-based lifecycle.
+@main
+class AppDelegate: UIResponder, UIApplicationDelegate {
+
+    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
+        // Hook for one-time process setup (e.g. analytics, remote config). Scene-specific UI setup belongs in SceneDelegate.
+        return true
+    }
+
+    // MARK: UISceneSession Lifecycle
+
+    func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
+        // Tells the system which storyboard / delegate class to use for this scene. Name must match an entry in Info.plist under Application Scene Manifest.
+        return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
+    }
+
+    func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
+        // Called after the user removes a window/scene from the app switcher. Tear down resources tied to those sessions only if you created any outside the scene itself.
+    }
+
+    // MARK: - Core Data stack
+
+    /// Lazily loads the persistent store on first access so cold launch stays fast until something touches the database.
+    lazy var persistentContainer: NSPersistentContainer = {
+        let container = NSPersistentContainer(name: "VideoEditor")
+        container.loadPersistentStores { _, error in
+            if let error = error as NSError? {
+                // Replace this with proper production-grade error handling.
+                // fatalError is intentional here to surface misconfigured
+                // data model issues during development.
+                fatalError("Unresolved Core Data error: \(error), \(error.userInfo)")
+            }
+        }
+        return container
+    }()
+
+    // MARK: - Core Data Saving Support
+
+    /// Persists pending changes on the main queue context. Call from lifecycle hooks (e.g. scene background) or after batched edits.
+    func saveContext() {
+        let context = persistentContainer.viewContext
+        guard context.hasChanges else { return }
+        do {
+            try context.save()
+        } catch {
+            let nserror = error as NSError
+            fatalError("Unresolved Core Data save error: \(nserror), \(nserror.userInfo)")
+        }
+    }
+}

App/AppRouter.swift

@@ -0,0 +1,208 @@
+//
+// AppRouter
+// VideoEditor
+//  Created by Coder ACJHP on 27.03.2026.
+
+
+import Foundation
+import UIKit
+
+enum Route: String, CaseIterable {
+    case landing
+    case editor
+    case export
+    case audioBottomSheet
+    case stickerBottomSheet
+    case textBottomSheet
+}
+
+// MARK: - RouterDelegate Protocol
+// Abstracts all navigation operations behind a protocol.
+// ViewControllers depend on this protocol instead of AppRouter directly,
+// making them testable and decoupled from the concrete router implementation.
+@MainActor
+protocol RouterDelegate: AnyObject {
+    func navigate(to route: Route, animated: Bool)   // Push
+    func present(to route: Route, animated: Bool)    // Modal present
+    func presentBottomSheet(
+        to route: Route,
+        config: SheetConfiguration,
+        animated: Bool
+    )    // BottomSheet
+    /// Presents a pre-built controller as a sheet (e.g. editor-owned `AudioBottomSheetViewController` with callbacks).
+    func presentBottomSheet(
+        _ viewController: UIViewController,
+        config: SheetConfiguration,
+        animated: Bool
+    )
+    func pop(animated: Bool)
+    func dismiss(animated: Bool)
+    func makeViewController(baseRoute route: Route) -> UIViewController  // Factory
+    /// Pushes the editor pre-loaded with a specific project. Prefer this over
+    /// `navigate(to: .editor)` because it properly injects the domain model.
+    func navigateToEditor(with project: EditingProject, animated: Bool)
+    /// Pushes export with the current timeline snapshot. Prefer over `navigate(to: .export)`.
+    func navigateToExport(with project: EditingProject, animated: Bool)
+    /// After a successful export, pushes the preview + share screen. Back pops export and result together.
+    func pushExportedVideoResult(fileURL: URL, animated: Bool)
+    /// Simple modal alert (e.g. export failure) presented from the navigation stack’s top view controller.
+    func presentAlert(title: String, message: String)
+}
+
+@MainActor
+class AppRouter: RouterDelegate {
+    
+    private let controller: UINavigationController
+    private let thumbnailService: ThumbnailGenerating
+    
+    init(
+        controller: UINavigationController,
+        thumbnailService: ThumbnailGenerating
+    ) {
+        self.controller = controller
+        self.thumbnailService = thumbnailService
+    }
+    
+    func navigate(to route: Route, animated: Bool) {
+        let destinationVC = makeViewController(baseRoute: route)
+        controller.pushViewController(destinationVC, animated: animated)
+    }
+    
+    func pop(animated: Bool) {
+        controller.popViewController(animated: animated)
+    }
+    
+    func present(to route: Route, animated: Bool) {
+        let destinationVC = makeViewController(baseRoute: route)
+        // Wraps in a new NavigationController so the modal has its own navigation stack
+        let nav = UINavigationController(rootViewController: destinationVC)
+        controller.present(nav, animated: animated)
+    }
+    
+    func dismiss(animated: Bool) {
+        controller.dismiss(animated: animated)
+    }
+    
+    func presentBottomSheet(to route: Route, config configuration: SheetConfiguration, animated: Bool) {
+        let bottomSheet = makeViewController(baseRoute: route)        
+        bottomSheet.modalPresentationStyle = .pageSheet
+        bottomSheet.isModalInPresentation = !configuration.isDismissable
+
+        if let sheet = bottomSheet.sheetPresentationController {
+            sheet.detents = configuration.detents
+            sheet.selectedDetentIdentifier = configuration.selectedIdentifier
+            sheet.prefersGrabberVisible = configuration.prefersGrabber
+            sheet.prefersScrollingExpandsWhenScrolledToEdge = configuration.prefersScrollExpand
+            sheet.preferredCornerRadius = configuration.cornerRadius
+
+            if let largestUndimmed = configuration.largestUndimmedIdentifier {
+                sheet.largestUndimmedDetentIdentifier = largestUndimmed
+            }
+        }
+
+        controller.present(bottomSheet, animated: animated, completion: nil)
+    }
+
+    func presentBottomSheet(_ viewController: UIViewController, config configuration: SheetConfiguration, animated: Bool) {
+        viewController.modalPresentationStyle = .pageSheet
+        viewController.isModalInPresentation = !configuration.isDismissable
+
+        if let sheet = viewController.sheetPresentationController {
+            sheet.detents = configuration.detents
+            sheet.selectedDetentIdentifier = configuration.selectedIdentifier
+            sheet.prefersGrabberVisible = configuration.prefersGrabber
+            sheet.prefersScrollingExpandsWhenScrolledToEdge = configuration.prefersScrollExpand
+            sheet.preferredCornerRadius = configuration.cornerRadius
+
+            if let largestUndimmed = configuration.largestUndimmedIdentifier {
+                sheet.largestUndimmedDetentIdentifier = largestUndimmed
+            }
+        }
+
+        controller.present(viewController, animated: animated, completion: nil)
+    }
+
+    func navigateToEditor(with project: EditingProject, animated: Bool) {
+        let viewModel = EditorViewModel(project: project)
+        let editorVC = EditorViewController(
+            router: self,
+            viewModel: viewModel,
+            thumbnailGenerator: thumbnailService
+        )
+        controller.pushViewController(editorVC, animated: animated)
+    }
+
+    func navigateToExport(with project: EditingProject, animated: Bool) {
+        let exporter = PhotoLibraryMovieExporter(
+            compositionBuilder: PreviewTimelineCompositionBuilder(),
+            mediaPermissions: SystemMediaPermissionService()
+        )
+        let exportVC = ExportViewController(
+            router: self,
+            project: project,
+            movieExporter: exporter
+        )
+        controller.pushViewController(exportVC, animated: animated)
+    }
+
+    func pushExportedVideoResult(fileURL: URL, animated: Bool) {
+        let resultVC = ExportedVideoResultViewController(fileURL: fileURL) { [weak self] in
+            self?.popExportResultFlow(animated: animated)
+        }
+        controller.pushViewController(resultVC, animated: animated)
+    }
+
+    func presentAlert(title: String, message: String) {
+        let alert = UIAlertController(title: title, message: message, preferredStyle: .alert)
+        alert.addAction(UIAlertAction(title: String(localized: "OK"), style: .default))
+        let presenter = controller.topViewController ?? controller
+        presenter.present(alert, animated: true)
+    }
+
+    /// Pops the export result screen and the export screen, returning to the screen below export (typically the editor).
+    private func popExportResultFlow(animated: Bool) {
+        let stack = controller.viewControllers
+        guard let exportIndex = stack.firstIndex(where: { $0 is ExportViewController }), exportIndex > 0 else {
+            if !stack.isEmpty { controller.popViewController(animated: animated) }
+            return
+        }
+        controller.popToViewController(stack[exportIndex - 1], animated: animated)
+    }
+
+    // MARK: ViewController Factory
+    // Single place responsible for creating ViewControllers and injecting the router.
+    // Adding a new screen only requires a new Route case and an entry here.
+    func makeViewController(baseRoute route: Route) -> UIViewController {
+        switch route {
+            case .landing:
+                return LandingViewController(router: self, thumbnailService: thumbnailService)
+            case .editor:
+                // Fallback with an empty project; prefer navigateToEditor(with:animated:) for real use.
+                let viewModel = EditorViewModel(project: EditingProject(name: "New Project"))
+                return EditorViewController(
+                    router: self,
+                    viewModel: viewModel,
+                    thumbnailGenerator: thumbnailService
+                )
+            case .export:
+                let exporter = PhotoLibraryMovieExporter(
+                    compositionBuilder: PreviewTimelineCompositionBuilder(),
+                    mediaPermissions: SystemMediaPermissionService()
+                )
+                return ExportViewController(
+                    router: self,
+                    project: EditingProject(name: String(localized: "Untitled"), tracks: []),
+                    movieExporter: exporter
+                )
+            case .audioBottomSheet:
+                return AudioBottomSheetViewController(router: self)
+            case .stickerBottomSheet:
+                return StickerBottomSheetViewController(router: self)
+            case .textBottomSheet:
+                return TextBottomSheetViewController(
+                    initialDescriptor: TextOverlayDescriptor.defaultNew(text: ""),
+                    onComplete: { _ in }
+                )
+        }
+    }
+}