@spaethtech/svelte-ui 0.19.0 → 0.19.1-dev.98.32fa323

package/dist/components/Query.svelte

@@ -242,8 +242,8 @@
           <tr><td>{"> >= < <="}</td><td>greater / less than (numbers &amp; dates)</td></tr>
           <tr><td>~= !~</td><td>contains / not — or regex if value is <code>/…/</code></td></tr>
           <tr><td>^= $=</td><td>starts / ends with</td></tr>
-          <tr><td>|=</td><td>any of a set <code>[a, b]</code> or range <code>[1..9)</code></td></tr>
-          <tr><td>&=</td><td>all of a set (multi-value columns)</td></tr>
+          <tr><td>|=</td><td>any of a set <code>[a, b]</code> (a member may be a regex <code>/…/</code>) or range <code>[1..9)</code></td></tr>
+          <tr><td>&=</td><td>all of a set (members may be regex <code>/…/</code>; multi-value columns)</td></tr>
         </tbody>
       </table>
     </div>
@@ -297,6 +297,7 @@
           <tr><td>$age |= [21..40)</td><td>range — 21 ≤ age &lt; 40</td></tr>
           <tr><td>$role |= [admin, ops]</td><td>any of a set</td></tr>
           <tr><td>$tags &amp;= [urgent, vip]</td><td>all of (multi-value column)</td></tr>
+          <tr><td>$services |= [/^Managed/, "Static IP"]</td><td>set member as a regex (per element)</td></tr>
           <tr><td>$created &gt;= now()-7d</td><td>dynamic date (last 7 days)</td></tr>
           <tr><td>$ip|inet &gt;= 10.0.0.0|inet</td><td>typed IP compare</td></tr>
           <tr><td>!($role == admin)</td><td>negate a group</td></tr>

package/dist/data/query/ast.d.ts

@@ -27,6 +27,14 @@ export declare function resolveNow(v: NowValue, at?: Date): Date;
 export type Cast = "number" | "string" | "bool" | "date" | "inet";
 /** Membership mode: `|=` matches ANY of the operand, `&=` matches ALL (e.g. array contains-all). */
 export type MemberMode = "any" | "all";
+/** A regex member inside a `|=`/`&=` set (`$col |= [/re/i]`). Reuses the `match`-node shape
+ *  (`source`/`flags`). Evaluated per array ELEMENT: a member matches if the regex tests true against
+ *  any element's string form (or the cell itself for a scalar column). A cast + a regex member is a
+ *  parse error, same as a bare `~=` regex. */
+export interface RegexMember {
+    source: string;
+    flags: string;
+}
 /** One end of an interval. `inclusive` reflects the bracket: `[`/`]` inclusive, `(`/`)` exclusive. */
 export type Bound = {
     value: Value;
@@ -63,6 +71,7 @@ export type QueryNode = {
     col: string;
     mode: MemberMode;
     values: Value[];
+    patterns?: RegexMember[];
     cast?: Cast;
 } | {
     kind: "range";

package/dist/data/query/eval.js

@@ -126,12 +126,19 @@ export function matchesRow(row, ast, opts = {}) {
             }
             case "in": {
                 const cell = get(row, node.col);
-                const members = node.values.map((v) => resolveVal(v, now));
-                if (Array.isArray(cell)) {
-                    const inCell = (m) => cell.some((c) => eq(c, m, node.cast, ci));
-                    return node.mode === "all" ? members.every(inCell) : members.some(inCell);
-                }
-                const hits = members.map((m) => eq(cell, m, node.cast, ci));
+                // One predicate per member. Scalars → exact-equality (honours cast + ci); regexes → test the
+                // string form. A member is satisfied if SOME array element matches it (per-element — the point
+                // of a regex member), or the cell itself for a scalar column.
+                const scalarTests = node.values.map((v) => {
+                    const m = resolveVal(v, now);
+                    return (x) => eq(x, m, node.cast, ci);
+                });
+                const regexTests = (node.patterns ?? []).map((p) => {
+                    const re = safeRegExp(p.source, p.flags);
+                    return (x) => re != null && re.test(toStr(x));
+                });
+                const memberHit = (test) => Array.isArray(cell) ? cell.some(test) : test(cell);
+                const hits = [...scalarTests, ...regexTests].map(memberHit);
                 return node.mode === "all" ? hits.every(Boolean) : hits.some(Boolean);
             }
             case "range": {

package/dist/data/query/parser.js

@@ -125,7 +125,7 @@ class Parser {
         const node = this.parseClauseBody(col);
         const cast = this.foldCast();
         if (cast) {
-            if (node.kind === "match")
+            if (node.kind === "match" || (node.kind === "in" && node.patterns?.length))
                 throw new QueryError("A cast cannot be used with a regex", colTok.start);
             node.cast = cast;
         }
@@ -224,6 +224,17 @@ class Parser {
         }
         return value;
     }
+    /** One member of a `[...]` set: a regex literal (→ per-element pattern) or a scalar (exact-equality).
+     *  A regex is only valid in a SET, never as an interval bound (a pattern can't order). */
+    parseSetMember() {
+        if (this.is("regex")) {
+            const r = this.next();
+            if (r.type !== "regex")
+                throw new QueryError("Expected a regex", r.start);
+            return { pattern: { source: r.source, flags: r.flags } };
+        }
+        return { value: this.parseScalar() };
+    }
     parseMemberOperand(col, mode) {
         const open = this.next();
         if (open.type !== "lbracket" && open.type !== "lparen") {
@@ -232,21 +243,28 @@ class Parser {
         const lowerInclusive = open.type === "lbracket";
         let lower = null;
         if (!this.is("dotdot")) {
-            const first = this.parseScalar();
-            if (this.is("dotdot")) {
-                lower = { value: first, inclusive: lowerInclusive };
+            const first = this.parseSetMember();
+            // Interval only when the first member is a SCALAR immediately followed by `..`; a regex first
+            // member (or a scalar not followed by `..`) is a set.
+            if (!first.pattern && this.is("dotdot")) {
+                lower = { value: first.value, inclusive: lowerInclusive };
             }
             else {
-                // SET (must use square brackets).
+                // SET (must use square brackets). Scalars → exact-equality members; regexes → per-element.
                 if (open.type !== "lbracket")
                     throw new QueryError("A set must use '[' ']'", open.start);
-                const values = [first];
+                const values = [];
+                const patterns = [];
+                const add = (m) => m.pattern ? patterns.push(m.pattern) : values.push(m.value);
+                add(first);
                 while (this.is("comma")) {
                     this.next();
-                    values.push(this.parseScalar());
+                    add(this.parseSetMember());
                 }
                 this.expect("rbracket");
-                return { kind: "in", col, mode, values };
+                return patterns.length
+                    ? { kind: "in", col, mode, values, patterns }
+                    : { kind: "in", col, mode, values };
             }
         }
         // interval

package/docs/components.md

@@ -400,7 +400,9 @@ Config-driven, responsive 12-column data table over a `DataGrid`.
 
 Filter bar over a `DataSet` — monospace input with `$column` + enum-value autocomplete and a help
 dialog (operators, casts, dynamic `now()` dates, and a worked examples table). The DSL supports
-`now()` / `now()±<n><unit>` dynamic dates — see the help dialog + the data spec.
+`now()` / `now()±<n><unit>` dynamic dates, and **regex members inside `|=`/`&=` sets** —
+`$services |= [/^Managed/, "Static IP"]` matches a set member as a regex, per array element (scalars
+still exact-match; mix freely). See the help dialog + the data spec.
 
 - **Location**: `src/lib/components/Query.svelte`
 - **Props**: `dataset` (`DataSet`), `placeholder`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spaethtech/svelte-ui",
-  "version": "0.19.0",
+  "version": "0.19.1-dev.98.32fa323",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/spaethtech/svelte-ui.git"