feat: 로딩 상태를 뷰모델마다 관리할 수 있는 객체 구현

Author: opficdev

DevLog/Presentation/Common/LoadingState.swift

@@ -0,0 +1,150 @@
+//
+//  LoadingState.swift
+//  DevLog
+//
+//  Created by opfic on 3/16/26.
+//
+
+import Foundation
+
+@MainActor
+final class LoadingState {
+    private enum DefaultTarget: Hashable {
+        case value
+    }
+
+    enum Mode {
+        case immediate
+        case delayed
+    }
+
+    private let delay: Duration
+    private var immediateCountByTarget: [AnyHashable: Int] = [:]
+    private var delayedCountByTarget: [AnyHashable: Int] = [:]
+    private var delayedTaskByTarget: [AnyHashable: Task<Void, Never>] = [:]
+    private var visibleDelayedTargets = Set<AnyHashable>()
+
+    init(delay: Duration = .milliseconds(500)) {
+        self.delay = delay
+    }
+
+    func begin(
+        mode: Mode,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        begin(target: DefaultTarget.value, mode: mode) { _, isLoading in
+            update(isLoading)
+        }
+    }
+
+    func begin<T: Hashable>(
+        target: T,
+        mode: Mode,
+        update: @escaping @MainActor (T, Bool) -> Void
+    ) {
+        let hashableTarget = AnyHashable(target)
+        begin(target: hashableTarget, mode: mode) { isLoading in
+            update(target, isLoading)
+        }
+    }
+
+    func end(
+        mode: Mode,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        end(target: DefaultTarget.value, mode: mode) { _, isLoading in
+            update(isLoading)
+        }
+    }
+
+    func end<T: Hashable>(
+        target: T,
+        mode: Mode,
+        update: @escaping @MainActor (T, Bool) -> Void
+    ) {
+        let hashableTarget = AnyHashable(target)
+        end(target: hashableTarget, mode: mode) { isLoading in
+            update(target, isLoading)
+        }
+    }
+
+    private func begin(
+        target: AnyHashable,
+        mode: Mode,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        switch mode {
+        case .immediate:
+            immediateCountByTarget[target, default: 0] += 1
+            update(true)
+        case .delayed:
+            delayedCountByTarget[target, default: 0] += 1
+            scheduleDelayedLoadingIfNeeded(for: target, update: update)
+        }
+    }
+
+    private func end(
+        target: AnyHashable,
+        mode: Mode,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        switch mode {
+        case .immediate:
+            let count = immediateCountByTarget[target, default: 0]
+            immediateCountByTarget[target] = max(0, count - 1)
+        case .delayed:
+            let count = delayedCountByTarget[target, default: 0]
+            delayedCountByTarget[target] = max(0, count - 1)
+        }
+        updateLoadingVisibility(for: target, update: update)
+    }
+
+    private func scheduleDelayedLoadingIfNeeded(
+        for target: AnyHashable,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        guard delayedTaskByTarget[target] == nil,
+              !visibleDelayedTargets.contains(target),
+              0 < delayedCountByTarget[target, default: 0] else { return }
+        delayedTaskByTarget[target] = Task { [weak self] in
+            guard let self else { return }
+            try? await Task.sleep(for: delay)
+            if Task.isCancelled { return }
+            await MainActor.run {
+                self.delayedTaskByTarget[target] = nil
+                guard 0 < self.delayedCountByTarget[target, default: 0] else { return }
+                self.visibleDelayedTargets.insert(target)
+                if self.immediateCountByTarget[target, default: 0] == 0 {
+                    update(true)
+                }
+            }
+        }
+    }
+
+    private func updateLoadingVisibility(
+        for target: AnyHashable,
+        update: @escaping @MainActor (Bool) -> Void
+    ) {
+        if 0 < immediateCountByTarget[target, default: 0] {
+            update(true)
+            return
+        }
+        if visibleDelayedTargets.contains(target) {
+            if delayedCountByTarget[target, default: 0] == 0 {
+                visibleDelayedTargets.remove(target)
+                update(false)
+            } else {
+                update(true)
+            }
+            return
+        }
+        if 0 < delayedCountByTarget[target, default: 0] {
+            update(false)
+            scheduleDelayedLoadingIfNeeded(for: target, update: update)
+            return
+        }
+        delayedTaskByTarget[target]?.cancel()
+        delayedTaskByTarget[target] = nil
+        update(false)
+    }
+}