feat: Add WithFuzzyFilter modifier to enable fuzzy filter matching

Author: IAL32

table/filter.go

@@ -75,3 +75,74 @@ func isRowMatched(columns []Column, row Row, filter string) bool {
 
 	return !checkedAny
 }
+
+// NewFuzzyFilter returns a filterFunc that performs case-insensitive fuzzy
+// matching (subsequence) over the concatenation of all filterable column values.
+// Example wiring:
+//
+//	m.filterFunc = NewFuzzyFilter(m.columns)
+func NewFuzzyFilter(columns []Column) func(Row, string) bool {
+	return func(row Row, filter string) bool {
+		filter = strings.TrimSpace(filter)
+		if filter == "" {
+			return true
+		}
+
+		// Concatenate all filterable values for this row into one string
+		var b strings.Builder
+		for _, col := range columns {
+			if !col.filterable {
+				continue
+			}
+			if v, ok := row.Data[col.key]; ok {
+				// Unwrap StyledCell if present
+				switch vv := v.(type) {
+				case StyledCell:
+					v = vv.Data
+				}
+
+				switch vv := v.(type) {
+				case string:
+					b.WriteString(vv)
+				case fmt.Stringer:
+					b.WriteString(vv.String())
+				default:
+					b.WriteString(fmt.Sprintf("%v", v))
+				}
+				b.WriteByte(' ')
+			}
+		}
+
+		haystack := strings.ToLower(b.String())
+		if haystack == "" {
+			return false
+		}
+
+		// Support multi-token filters: "acme stl" must fuzzy-match both tokens
+		for _, token := range strings.Fields(strings.ToLower(filter)) {
+			if !fuzzySubsequenceMatch(haystack, token) {
+				return false
+			}
+		}
+		return true
+	}
+}
+
+// fuzzySubsequenceMatch returns true if all runes in needle appear in order
+// within haystack (not necessarily contiguously). Case must be normalized by caller.
+func fuzzySubsequenceMatch(haystack, needle string) bool {
+	if needle == "" {
+		return true
+	}
+	hi, ni := 0, 0
+	hr := []rune(haystack)
+	nr := []rune(needle)
+
+	for hi < len(hr) && ni < len(nr) {
+		if hr[hi] == nr[ni] {
+			ni++
+		}
+		hi++
+	}
+	return ni == len(nr)
+}

table/filter_test.go

@@ -420,3 +420,115 @@ func BenchmarkFilteredRenders(b *testing.B) {
 		_ = model.View()
 	}
 }
+
+func TestFuzzyFilter_EmptyFilterMatchesAll(t *testing.T) {
+	cols := []Column{
+		NewColumn("name", "Name", 10).WithFiltered(true),
+	}
+	rows := []Row{
+		NewRow(RowData{"name": "Acme Steel"}),
+		NewRow(RowData{"name": "Globex"}),
+	}
+
+	ff := NewFuzzyFilter(cols)
+
+	for i, r := range rows {
+		if !ff(r, "") {
+			t.Fatalf("row %d should match empty filter", i)
+		}
+	}
+}
+
+func TestFuzzyFilter_SubsequenceAcrossColumns(t *testing.T) {
+	cols := []Column{
+		NewColumn("name", "Name", 10).WithFiltered(true),
+		NewColumn("city", "City", 10).WithFiltered(true),
+	}
+	row := NewRow(RowData{
+		"name": "Acme",
+		"city": "Stuttgart",
+	})
+
+	ff := NewFuzzyFilter(cols)
+
+	// subsequence match: "agt" appears in order inside "stuttgart"
+	if !ff(row, "agt") {
+		t.Fatalf("expected subsequence 'agt' to match 'Stuttgart'")
+	}
+	// case-insensitive
+	if !ff(row, "ACM") {
+		t.Fatalf("expected case-insensitive subsequence to match 'Acme'")
+	}
+	// not a subsequence
+	if ff(row, "zzt") {
+		t.Fatalf("did not expect 'zzt' to match")
+	}
+}
+
+func TestFuzzyFilter_MultiToken_AND(t *testing.T) {
+	cols := []Column{
+		NewColumn("name", "Name", 10).WithFiltered(true),
+		NewColumn("dept", "Dept", 10).WithFiltered(true),
+	}
+	row := NewRow(RowData{
+		"name": "Wayne Enterprises",
+		"dept": "R&D",
+	})
+
+	ff := NewFuzzyFilter(cols)
+
+	// Both tokens must match as subsequences somewhere in the concatenated haystack
+	if !ff(row, "wy ent") { // "wy" in Wayne, "ent" in Enterprises
+		t.Fatalf("expected multi-token AND to match")
+	}
+	if ff(row, "wy zzz") {
+		t.Fatalf("expected multi-token AND to fail when a token doesn't match")
+	}
+}
+
+func TestFuzzyFilter_IgnoresNonFilterableColumns(t *testing.T) {
+	cols := []Column{
+		NewColumn("name", "Name", 10).WithFiltered(true),
+		NewColumn("secret", "Secret", 10).WithFiltered(false), // should be ignored
+	}
+	row := NewRow(RowData{
+		"name":   "Acme",
+		"secret": "topsecretpattern",
+	})
+
+	ff := NewFuzzyFilter(cols)
+
+	if ff(row, "topsecret") {
+		t.Fatalf("should not match on non-filterable column content")
+	}
+}
+
+func TestFuzzyFilter_UnwrapsStyledCell(t *testing.T) {
+	cols := []Column{
+		NewColumn("name", "Name", 10).WithFiltered(true),
+	}
+	row := NewRow(RowData{
+		"name": NewStyledCell("Nakatomi Plaza", lipgloss.NewStyle()),
+	})
+
+	ff := NewFuzzyFilter(cols)
+
+	if !ff(row, "nak plz") {
+		t.Fatalf("expected fuzzy subsequence to match within StyledCell data")
+	}
+}
+
+func TestFuzzyFilter_NonStringValuesFormatted(t *testing.T) {
+	cols := []Column{
+		NewColumn("id", "ID", 6).WithFiltered(true),
+	}
+	row := NewRow(RowData{
+		"id": 12345, // should be formatted via fmt.Sprintf("%v", v)
+	})
+
+	ff := NewFuzzyFilter(cols)
+
+	if !ff(row, "245") { // subsequence of "12345"
+		t.Fatalf("expected matcher to format non-strings and match subsequence")
+	}
+}

table/options.go

@@ -376,6 +376,12 @@ func (m Model) WithFilterFunc(shouldInclude func(row Row, filterInput string) bo
 	return m
 }
 
+func (m Model) WithFuzzyFilter() Model {
+	m.filterFunc = NewFuzzyFilter(m.columns)
+
+	return m
+}
+
 // WithFooterVisibility sets the visibility of the footer.
 func (m Model) WithFooterVisibility(visibility bool) Model {
 	m.footerVisible = visibility