Throttle function to be able to guarantee first and last operations.

advance_throttle.swift

enum TaskType {
    case current
    case main
}

enum ThrottleType {
    case none
    case immediateFirst
    case guaranteeLast
    case both
}

var lastThrottleDate: Date?
var debounceTimer: Timer?
var operations = [(() -> Void)]()

func throttle(
    _ interval: Duration = .seconds(1),
    on taskType: TaskType = .main,
    type: ThrottleType = .none,
    operation: @escaping () -> Void
) {
    let now = Date()
    let timeInterval = TimeInterval(interval.components.seconds) + Double(interval.components.attoseconds)/1e18
    let isThrottlingPeriod = lastThrottleDate != nil && now.timeIntervalSince(lastThrottleDate!) < timeInterval
    
    let debounceInterval = {
        let debounceFactor: Double = 1.1
        return timeInterval * debounceFactor
    }()

    let operation = {
        Task { taskType == .main ? await MainActor.run { operation() } : operation() }
        lastThrottleDate = now
    }
    
    let debounce = {
        debounceTimer?.invalidate()
        debounceTimer = Timer.scheduledTimer(withTimeInterval: debounceInterval, repeats: false) { _ in
            operation()
        }
    }
    
    lazy var canRun = lastThrottleDate == nil || !isThrottlingPeriod
    
    switch type {
    case .none:
        if !isThrottlingPeriod {
            operation()
        }
    case .immediateFirst:
        if canRun {
            operation()
        }
    case .guaranteeLast:
        isThrottlingPeriod ? debounce() : operation()
    case .both:
        canRun ? operation() : debounce()
    }
}

/// you can use it like this

/* 
throttle(type: .both) {
    search(text: text)
}
*/