Remove continuously sequences within a delaying time

Debouncer.swift

// 
// A -> B -> C -> D
// `keepFirst`: A
// `keepLast`: D
//
enum DebouncerType {
    case keepFirst
    case keepLast
}

final class Debouncer: NSObject {
    private var block: (() -> Void)?
    private var timer: Timer?
    private var type: DebouncerType
    private var isKeepingFirst = false
    
    init(type: DebouncerType = .keepLast) {
        self.type = type
    }
    
    func dispatch(delay: Double = 0.25, block: @escaping (() -> Void)) {
        switch type {
        case .keepFirst:
            guard !isKeepingFirst else { return }
            isKeepingFirst = true
            block()
        case .keepLast:
            invalidate()
            self.block = block
        }
        timer = Timer.scheduledTimer(timeInterval: delay, target: self, selector: #selector(Debouncer.callback), userInfo: nil, repeats: false)
    }
    
    @objc func callback() {
        switch type {
        case .keepFirst:
            invalidate()
            isKeepingFirst = false
        case .keepLast:
            self.block?()
        }
    }
    
    func invalidate() {
        timer?.invalidate()
        timer = nil
    }
}