···

       
89
       
 
       
      .map((f) => f.trim())

     

       
90
       
 
       
      .filter((f) => f.length > 0);

     

       
91
       
 
       


     

       
92
       
-
       
    const exclusions: string[] = [];

     

       
93
       
-
       
    const inclusions: string[] = [];

     

       
94
       
 
       


     

       
95
       
 
       
    filters.forEach((f) => {

     

       
96
       
 
       
      if (f.startsWith("-")) {

     

       
97
       
-
       
        exclusions.push(f.slice(1).toLowerCase());

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
98
       
 
       
      } else {

     

       
99
       
-
       
        inclusions.push(f.toLowerCase());

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
100
       
 
       
      }

     

       
101
       
 
       
    });

     

       
102
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
103
       
 
       
    return labels().filter((label) => {

     

       
104
       
 
       
      const labelValue = label.val.toLowerCase();

     

       
105
       
 
       


     

       
106
       
-
       
      // Check exclusions (exact match)

     

       
107
       
-
       
      if (exclusions.some((exc) => labelValue === exc)) {

     

       
108
       
 
       
        return false;

     

       
109
       
 
       
      }

     

       
110
       
 
       


     

       
111
       
-
       
      // If there are inclusions, at least one must match (partial match)

     

       
112
       
 
       
      if (inclusions.length > 0) {

     

       
113
       
-
       
        return inclusions.some((inc) => labelValue.includes(inc));

     

       
114
       
 
       
      }

     

       
115
       
 
       


     

       
116
       
 
       
      // If only exclusions were specified, include everything not excluded

     
···

       
247
       
 
       
        <StickyOverlay>

     

       
248
       
 
       
          <div class="flex w-full items-center gap-x-2">

     

       
249
       
 
       
            <TextInput

     

       
250
       
-
       
              placeholder="Filter labels (space separated, -label to exclude)"

     

       
251
       
 
       
              name="filter"

     

       
252
       
 
       
              value={filter()}

     

       
253
       
 
       
              onInput={(e) => setFilter(e.currentTarget.value)}

     

···

       
89
       
 
       
      .map((f) => f.trim())

     

       
90
       
 
       
      .filter((f) => f.length > 0);

     

       
91
       
 
       


     

       
92
       
+
       
    const exclusions: { pattern: string; hasWildcard: boolean }[] = [];

     

       
93
       
+
       
    const inclusions: { pattern: string; hasWildcard: boolean }[] = [];

     

       
94
       
 
       


     

       
95
       
 
       
    filters.forEach((f) => {

     

       
96
       
 
       
      if (f.startsWith("-")) {

     

       
97
       
+
       
        const lower = f.slice(1).toLowerCase();

     

       
98
       
+
       
        exclusions.push({

     

       
99
       
+
       
          pattern: lower,

     

       
100
       
+
       
          hasWildcard: lower.includes("*"),

     

       
101
       
+
       
        });

     

       
102
       
 
       
      } else {

     

       
103
       
+
       
        const lower = f.toLowerCase();

     

       
104
       
+
       
        inclusions.push({

     

       
105
       
+
       
          pattern: lower,

     

       
106
       
+
       
          hasWildcard: lower.includes("*"),

     

       
107
       
+
       
        });

     

       
108
       
 
       
      }

     

       
109
       
 
       
    });

     

       
110
       
 
       


     

       
111
       
+
       
    const matchesPattern = (value: string, filter: { pattern: string; hasWildcard: boolean }) => {

     

       
112
       
+
       
      if (filter.hasWildcard) {

     

       
113
       
+
       
        // Convert wildcard pattern to regex

     

       
114
       
+
       
        const regexPattern = filter.pattern

     

       
115
       
+
       
          .replace(/[.+?^${}()|[\]\\]/g, "\\$&") // Escape special regex chars except *

     

       
116
       
+
       
          .replace(/\*/g, ".*"); // Replace * with .*

     

       
117
       
+
       
        const regex = new RegExp(`^${regexPattern}$`);

     

       
118
       
+
       
        return regex.test(value);

     

       
119
       
+
       
      } else {

     

       
120
       
+
       
        return value === filter.pattern;

     

       
121
       
+
       
      }

     

       
122
       
+
       
    };

     

       
123
       
+
       


     

       
124
       
 
       
    return labels().filter((label) => {

     

       
125
       
 
       
      const labelValue = label.val.toLowerCase();

     

       
126
       
 
       


     

       
127
       
+
       
      if (exclusions.some((exc) => matchesPattern(labelValue, exc))) {

     

       
0
       
 
       

     

       
128
       
 
       
        return false;

     

       
129
       
 
       
      }

     

       
130
       
 
       


     

       
131
       
+
       
      // If there are inclusions, at least one must match

     

       
132
       
 
       
      if (inclusions.length > 0) {

     

       
133
       
+
       
        return inclusions.some((inc) => matchesPattern(labelValue, inc));

     

       
134
       
 
       
      }

     

       
135
       
 
       


     

       
136
       
 
       
      // If only exclusions were specified, include everything not excluded

     
···

       
267
       
 
       
        <StickyOverlay>

     

       
268
       
 
       
          <div class="flex w-full items-center gap-x-2">

     

       
269
       
 
       
            <TextInput

     

       
270
       
+
       
              placeholder="Filter labels (* for partial, -exclude)"

     

       
271
       
 
       
              name="filter"

     

       
272
       
 
       
              value={filter()}

     

       
273
       
 
       
              onInput={(e) => setFilter(e.currentTarget.value)}