Fix count reset

Author: floatdrop

v2/debounce.go

@@ -1,44 +1,52 @@
+// Package debounce provides a generic debounce utility for channels.
+// It allows throttling the rate of emitted values using optional delay and/or limit mechanisms.
 package debounce
 
 import (
 	"time"
 )
 
-// Option is a functional option for configuring the debouncer.
-type Option func(*debounceOptions)
-
-type debounceOptions struct {
+// options encapsulates the debounce configuration: delay and limit.
+type options struct {
 	limit int
 	delay time.Duration
 }
 
-// WithLimit sets the maximum number of incoming inputs before
-// passing most recent value downstream.
+// Option is a functional option for configuring the debouncer.
+type Option func(*options)
+
+// WithLimit sets a maximum number of times the debounce delay can be reset
+// before a value is forcibly emitted. This acts as a safeguard against constant bouncing.
 func WithLimit(limit int) Option {
-	return func(options *debounceOptions) {
+	return func(options *options) {
 		options.limit = limit
 	}
 }
 
-// WithDelay sets time.Duration specifying how long to wait after the last input
-// before sending the most recent value downstream.
+// WithDelay sets the debounce delay — the amount of quiet time (no new inputs)
+// required before emitting the most recent value.
 func WithDelay(d time.Duration) Option {
-	return func(options *debounceOptions) {
+	return func(options *options) {
 		options.delay = d
 	}
 }
 
-// Chan wraps incoming channel and returns channel that emits the last value only
-// after no new values are received for the given delay or limit.
+// Chan wraps an input channel and returns a debounced output channel.
+// Debouncing behavior is defined by the combination of WithDelay and WithLimit:
+//   - WithDelay delays value emission until no new values are received for `delay`.
+//   - WithLimit limits the number of delay resets (i.e., bouncing) before emission is forced.
+//
+// If both are set, a value will be emitted after either the `delay` passes without new input,
+// or after the delay has been reset `limit` times.
 //
-// If no delay provided - zero delay assumed, so function returns in chan as result.
+// If delay is 0, the function returns the input channel unmodified.
 func Chan[T any](in <-chan T, opts ...Option) <-chan T {
-	var options debounceOptions
+	var options options
 	for _, opt := range opts {
 		opt(&options)
 	}
 
-	// If there is no duration - every incoming element must be passed downstream.
+	// Optimization: no debouncing if delay is zero
 	if options.delay == 0 {
 		return in
 	}
@@ -48,16 +56,16 @@ func Chan[T any](in <-chan T, opts ...Option) <-chan T {
 		defer close(out)
 
 		var (
-			timer  *time.Timer = time.NewTimer(options.delay)
-			value  T
-			hasVal bool
-			count  int
+			timer     *time.Timer // Timer to manage delay
+			lastValue T           // Last received value
+			hasValue  bool        // Whether a value is currently pending emission
+			count     int         // Number of delay resets since last emission
 		)
 
 		// Function to return the timer channel or nil if timer is not set
 		// This avoids blocking on the timer channel if no timer is set
 		timerOrNil := func() <-chan time.Time {
-			if timer != nil && hasVal {
+			if timer != nil {
 				return timer.C
 			}
 			return nil
@@ -66,29 +74,44 @@ func Chan[T any](in <-chan T, opts ...Option) <-chan T {
 		for {
 			select {
 			case v, ok := <-in:
-				if !ok { // Input channel is closed, wrapping up
-					if hasVal {
-						out <- value
+				if !ok {
+					// Input channel closed — emit any pending value.
+					if hasValue {
+						out <- lastValue
 					}
 					return
 				}
 
-				if options.limit != 0 { // If WithLimit specified as non-zero value start counting and emitting
-					count++
-					if count >= options.limit {
-						out <- v
-						hasVal = false
+				lastValue = v
+				hasValue = true
+
+				// On every new input, increment the reset count.
+				count++
+
+				// Force emit if limit reached
+				if options.limit != 0 && count >= options.limit {
+					out <- v
+					hasValue = false
+					count = 0
+					if timer != nil {
 						timer.Stop()
-						continue
 					}
+					continue
 				}
 
-				value = v
-				hasVal = true
-				timer.Reset(options.delay)
+				// Start or reset the delay timer
+				if timer == nil {
+					timer = time.NewTimer(options.delay)
+				} else {
+					timer.Reset(options.delay)
+				}
 			case <-timerOrNil():
-				out <- value
-				hasVal = false
+				// Delay has passed — emit the last value
+				if hasValue {
+					out <- lastValue
+					hasValue = false
+					count = 0
+				}
 			}
 		}
 	}()

v2/debounce_test.go

@@ -81,11 +81,17 @@ func TestDebounce_WithLimit(t *testing.T) {
 		in <- 3
 		time.Sleep(50 * time.Millisecond)
 		in <- 4
+		time.Sleep(50 * time.Millisecond)
+		in <- 5
+		time.Sleep(50 * time.Millisecond)
+		in <- 6
+		time.Sleep(50 * time.Millisecond)
+		in <- 7
 		time.Sleep(300 * time.Millisecond) // wait longer than debounce delay
 		close(in)
 	}()
 
-	expected := []int{3, 4}
+	expected := []int{3, 6, 7}
 	result := collect(out, 1*time.Second)
 	if !slices.Equal(expected, result) {
 		t.Errorf("expected result = %v, got %v", expected, result)