@reopt-ai/opt-ui 1.6.0 → 1.8.0

package/dist/query.d.cts

@@ -0,0 +1,141 @@
+//#region src/lib/query/query-ast.d.ts
+/**
+ * A search query, as a value.
+ *
+ * Free-text search and a row of filter pickers answer different halves of the
+ * same question, and neither can express the other: a picker cannot say "not
+ * this", and a text box cannot say "this field, exactly". A parsed query is one
+ * thing that does both, and — because it is a value rather than a widget's
+ * internal state — it survives a URL, a saved view, and the trip to a server
+ * that has to turn it into a database filter.
+ *
+ * The grammar follows the one analytics tools have converged on (Elastic's
+ * `EuiSearchBar`, Kibana, GitHub's issue search), minus the parts that only
+ * make sense against a Lucene index:
+ *
+ *   error                  a term anywhere in the row
+ *   "connection reset"     a phrase, kept together
+ *   -health                a term that must not appear
+ *   path:/checkout         a field equal to a value
+ *   path:(/a or /b)        a field equal to any of several values
+ *   -status:200            a field that must not equal a value
+ *   status>=500            a comparison
+ *   path:*checkout*        the field contains this somewhere
+ *   utm_source:*           the field is present at all
+ *
+ * Clauses combine with AND; `or` only groups values inside one field. That is
+ * a deliberate ceiling: arbitrary boolean nesting reads worse than it queries,
+ * and every backend this targets can express the restricted form directly.
+ */
+/** How a field clause compares. */
+type QueryOperator = "eq" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
+/** A bare or quoted word matched against the whole row. */
+interface QueryTermClause {
+  type: "term";
+  value: string;
+  negated: boolean;
+}
+/** A constraint on one named field. Several values read as "any of". */
+interface QueryFieldClause {
+  type: "field";
+  field: string;
+  operator: QueryOperator;
+  values: string[];
+  negated: boolean;
+}
+type QueryClause = QueryTermClause | QueryFieldClause;
+/** A parsed query: clauses combined with AND. */
+interface Query {
+  clauses: QueryClause[];
+}
+declare const EMPTY_QUERY: Query;
+/** Whether a query constrains anything at all. */
+declare function isEmptyQuery(query: Query | null | undefined): boolean;
+/** Add a clause unless an identical one is already there. */
+declare function addClause(query: Query, clause: QueryClause): Query;
+/**
+ * Constrain a field to a value — what a cell's "filter for this" action does.
+ *
+ * Applying the opposite of a constraint already present replaces it rather than
+ * adding it: `status:200` then "filter out 200" should read as one changed
+ * mind, not as a query that can never match.
+ */
+declare function withFieldValue(query: Query, field: string, value: string, options?: {
+  negated?: boolean;
+  operator?: QueryOperator;
+}): Query;
+/** Drop every clause naming `field`. */
+declare function withoutField(query: Query, field: string): Query;
+/** Drop the clause at `index`, for a removable chip. */
+declare function removeClause(query: Query, index: number): Query;
+/** Every field the query names, in the order they first appear. */
+declare function queryFields(query: Query): string[];
+/** The values a field is constrained to, if any — for showing a filter as active. */
+declare function fieldValues(query: Query, field: string): string[];
+/** What a "filter for / filter out" control on a value asks for. */
+interface QueryCellAction {
+  field: string;
+  value: string;
+  intent: "include" | "exclude";
+}
+/**
+ * Fold a cell action into the query.
+ *
+ * The pair of buttons on a log cell is the fastest path from "I noticed this
+ * value" to a filtered view, and the reason it works is that the result is a
+ * query the reader can then see, edit and share — not a hidden filter stack
+ * with its own rules.
+ */
+declare function applyCellAction(query: Query, action: QueryCellAction): Query;
+//#endregion
+//#region src/lib/query/query-parse.d.ts
+/** A part of the input that could not be read as intended. */
+interface QueryDiagnostic {
+  /** Character offset into the original string. */
+  at: number;
+  text: string;
+  message: string;
+}
+interface ParsedQuery {
+  query: Query;
+  diagnostics: QueryDiagnostic[];
+  /** The final clause is still being typed — the caller can complete it. */
+  trailing: {
+    field: string;
+    operator: QueryOperator;
+    value: string;
+  } | null;
+}
+/** Parse, keeping whatever could not be understood as a plain term. */
+declare function parseQueryWithDiagnostics(input: string): ParsedQuery;
+/** Parse, discarding diagnostics. */
+declare function parseQuery(input: string): Query;
+//#endregion
+//#region src/lib/query/query-format.d.ts
+/** Quote a value that would otherwise re-parse as something else. */
+declare function quoteValue(value: string): string;
+/** One clause as text. */
+declare function formatClause(clause: QueryClause): string;
+/** The whole query as text. */
+declare function formatQuery(query: Query): string;
+/** A short human label for a clause chip. */
+declare function describeClause(clause: QueryClause): string;
+//#endregion
+//#region src/lib/query/query-match.d.ts
+/** How a row exposes its values. Missing fields return `undefined`. */
+type FieldReader = (field: string) => unknown;
+/**
+ * Whether one row satisfies every clause.
+ *
+ * `searchable` is lazy because most queries are field constraints, and
+ * flattening a row to text for a term match nobody asked for is the expensive
+ * part of filtering a live tail.
+ */
+declare function matchesQuery(query: Query, read: FieldReader, searchable: () => string): boolean;
+/** Convenience for plain objects, including one level of nested properties. */
+declare function matchesQueryObject(query: Query, row: Record<string, unknown>, options?: {
+  nested?: string;
+}): boolean;
+//#endregion
+export { EMPTY_QUERY, type FieldReader, type ParsedQuery, type Query, type QueryCellAction, type QueryClause, type QueryDiagnostic, type QueryFieldClause, type QueryOperator, type QueryTermClause, addClause, applyCellAction, describeClause, fieldValues, formatClause, formatQuery, isEmptyQuery, matchesQuery, matchesQueryObject, parseQuery, parseQueryWithDiagnostics, queryFields, quoteValue, removeClause, withFieldValue, withoutField };
+//# sourceMappingURL=query.d.cts.map

package/dist/query.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.cts","names":[],"sources":["../src/lib/query/query-ast.ts","../src/lib/query/query-parse.ts","../src/lib/query/query-format.ts","../src/lib/query/query-match.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BY;;UAUK;EACf;EACA;EACA;;;UAIe;EACf;EACA;EACA,UAAU;EACV;EACA;;KAGU,cAAc,kBAAkB;;UAG3B;EACf,SAAS;;cAGE,aAAa;;iBAGV,aAAa,OAAO;;iBAyBpB,UAAU,OAAO,OAAO,QAAQ,cAAc;;;;;;;;iBAc9C,eACd,OAAO,OACP,eACA,eACA;EAAW;EAAmB,WAAW;IACxC;;iBAsBa,aAAa,OAAO,OAAO,gBAAgB;;iBAS3C,aAAa,OAAO,OAAO,gBAAgB;;iBAK3C,YAAY,OAAO;;iBAWnB,YAAY,OAAO,OAAO;;UAazB;EACf;EACA;EACA;;;;;;;;;;iBAWc,gBAAgB,OAAO,OAAO,QAAQ,kBAAkB;;;;UCjKvD;;EAEf;EACA;EACA;;UAGe;EACf,OAAO;EACP,aAAa;;EAEb;IAAY;IAAe,UAAU;IAAe;;;;iBAoHtC,0BAA0B,gBAAgB;;iBAoG1C,WAAW,gBAAgB;;;;iBCrO3B,WAAW;;iBAOX,aAAa,QAAQ;;iBAgBrB,YAAY,OAAO;;iBAKnB,eAAe,QAAQ;;;;KCjC3B,eAAe;;;;;;;;iBA8DX,aACd,OAAO,OACP,MAAM,aACN;;iBASc,mBACd,OAAO,OACP,KAAK,yBACL;EAAW"}

package/dist/query.d.ts

@@ -0,0 +1,141 @@
+//#region src/lib/query/query-ast.d.ts
+/**
+ * A search query, as a value.
+ *
+ * Free-text search and a row of filter pickers answer different halves of the
+ * same question, and neither can express the other: a picker cannot say "not
+ * this", and a text box cannot say "this field, exactly". A parsed query is one
+ * thing that does both, and — because it is a value rather than a widget's
+ * internal state — it survives a URL, a saved view, and the trip to a server
+ * that has to turn it into a database filter.
+ *
+ * The grammar follows the one analytics tools have converged on (Elastic's
+ * `EuiSearchBar`, Kibana, GitHub's issue search), minus the parts that only
+ * make sense against a Lucene index:
+ *
+ *   error                  a term anywhere in the row
+ *   "connection reset"     a phrase, kept together
+ *   -health                a term that must not appear
+ *   path:/checkout         a field equal to a value
+ *   path:(/a or /b)        a field equal to any of several values
+ *   -status:200            a field that must not equal a value
+ *   status>=500            a comparison
+ *   path:*checkout*        the field contains this somewhere
+ *   utm_source:*           the field is present at all
+ *
+ * Clauses combine with AND; `or` only groups values inside one field. That is
+ * a deliberate ceiling: arbitrary boolean nesting reads worse than it queries,
+ * and every backend this targets can express the restricted form directly.
+ */
+/** How a field clause compares. */
+type QueryOperator = "eq" | "contains" | "gt" | "gte" | "lt" | "lte" | "exists";
+/** A bare or quoted word matched against the whole row. */
+interface QueryTermClause {
+  type: "term";
+  value: string;
+  negated: boolean;
+}
+/** A constraint on one named field. Several values read as "any of". */
+interface QueryFieldClause {
+  type: "field";
+  field: string;
+  operator: QueryOperator;
+  values: string[];
+  negated: boolean;
+}
+type QueryClause = QueryTermClause | QueryFieldClause;
+/** A parsed query: clauses combined with AND. */
+interface Query {
+  clauses: QueryClause[];
+}
+declare const EMPTY_QUERY: Query;
+/** Whether a query constrains anything at all. */
+declare function isEmptyQuery(query: Query | null | undefined): boolean;
+/** Add a clause unless an identical one is already there. */
+declare function addClause(query: Query, clause: QueryClause): Query;
+/**
+ * Constrain a field to a value — what a cell's "filter for this" action does.
+ *
+ * Applying the opposite of a constraint already present replaces it rather than
+ * adding it: `status:200` then "filter out 200" should read as one changed
+ * mind, not as a query that can never match.
+ */
+declare function withFieldValue(query: Query, field: string, value: string, options?: {
+  negated?: boolean;
+  operator?: QueryOperator;
+}): Query;
+/** Drop every clause naming `field`. */
+declare function withoutField(query: Query, field: string): Query;
+/** Drop the clause at `index`, for a removable chip. */
+declare function removeClause(query: Query, index: number): Query;
+/** Every field the query names, in the order they first appear. */
+declare function queryFields(query: Query): string[];
+/** The values a field is constrained to, if any — for showing a filter as active. */
+declare function fieldValues(query: Query, field: string): string[];
+/** What a "filter for / filter out" control on a value asks for. */
+interface QueryCellAction {
+  field: string;
+  value: string;
+  intent: "include" | "exclude";
+}
+/**
+ * Fold a cell action into the query.
+ *
+ * The pair of buttons on a log cell is the fastest path from "I noticed this
+ * value" to a filtered view, and the reason it works is that the result is a
+ * query the reader can then see, edit and share — not a hidden filter stack
+ * with its own rules.
+ */
+declare function applyCellAction(query: Query, action: QueryCellAction): Query;
+//#endregion
+//#region src/lib/query/query-parse.d.ts
+/** A part of the input that could not be read as intended. */
+interface QueryDiagnostic {
+  /** Character offset into the original string. */
+  at: number;
+  text: string;
+  message: string;
+}
+interface ParsedQuery {
+  query: Query;
+  diagnostics: QueryDiagnostic[];
+  /** The final clause is still being typed — the caller can complete it. */
+  trailing: {
+    field: string;
+    operator: QueryOperator;
+    value: string;
+  } | null;
+}
+/** Parse, keeping whatever could not be understood as a plain term. */
+declare function parseQueryWithDiagnostics(input: string): ParsedQuery;
+/** Parse, discarding diagnostics. */
+declare function parseQuery(input: string): Query;
+//#endregion
+//#region src/lib/query/query-format.d.ts
+/** Quote a value that would otherwise re-parse as something else. */
+declare function quoteValue(value: string): string;
+/** One clause as text. */
+declare function formatClause(clause: QueryClause): string;
+/** The whole query as text. */
+declare function formatQuery(query: Query): string;
+/** A short human label for a clause chip. */
+declare function describeClause(clause: QueryClause): string;
+//#endregion
+//#region src/lib/query/query-match.d.ts
+/** How a row exposes its values. Missing fields return `undefined`. */
+type FieldReader = (field: string) => unknown;
+/**
+ * Whether one row satisfies every clause.
+ *
+ * `searchable` is lazy because most queries are field constraints, and
+ * flattening a row to text for a term match nobody asked for is the expensive
+ * part of filtering a live tail.
+ */
+declare function matchesQuery(query: Query, read: FieldReader, searchable: () => string): boolean;
+/** Convenience for plain objects, including one level of nested properties. */
+declare function matchesQueryObject(query: Query, row: Record<string, unknown>, options?: {
+  nested?: string;
+}): boolean;
+//#endregion
+export { EMPTY_QUERY, type FieldReader, type ParsedQuery, type Query, type QueryCellAction, type QueryClause, type QueryDiagnostic, type QueryFieldClause, type QueryOperator, type QueryTermClause, addClause, applyCellAction, describeClause, fieldValues, formatClause, formatQuery, isEmptyQuery, matchesQuery, matchesQueryObject, parseQuery, parseQueryWithDiagnostics, queryFields, quoteValue, removeClause, withFieldValue, withoutField };
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","names":[],"sources":["../src/lib/query/query-ast.ts","../src/lib/query/query-parse.ts","../src/lib/query/query-format.ts","../src/lib/query/query-match.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BY;;UAUK;EACf;EACA;EACA;;;UAIe;EACf;EACA;EACA,UAAU;EACV;EACA;;KAGU,cAAc,kBAAkB;;UAG3B;EACf,SAAS;;cAGE,aAAa;;iBAGV,aAAa,OAAO;;iBAyBpB,UAAU,OAAO,OAAO,QAAQ,cAAc;;;;;;;;iBAc9C,eACd,OAAO,OACP,eACA,eACA;EAAW;EAAmB,WAAW;IACxC;;iBAsBa,aAAa,OAAO,OAAO,gBAAgB;;iBAS3C,aAAa,OAAO,OAAO,gBAAgB;;iBAK3C,YAAY,OAAO;;iBAWnB,YAAY,OAAO,OAAO;;UAazB;EACf;EACA;EACA;;;;;;;;;;iBAWc,gBAAgB,OAAO,OAAO,QAAQ,kBAAkB;;;;UCjKvD;;EAEf;EACA;EACA;;UAGe;EACf,OAAO;EACP,aAAa;;EAEb;IAAY;IAAe,UAAU;IAAe;;;;iBAoHtC,0BAA0B,gBAAgB;;iBAoG1C,WAAW,gBAAgB;;;;iBCrO3B,WAAW;;iBAOX,aAAa,QAAQ;;iBAgBrB,YAAY,OAAO;;iBAKnB,eAAe,QAAQ;;;;KCjC3B,eAAe;;;;;;;;iBA8DX,aACd,OAAO,OACP,MAAM,aACN;;iBASc,mBACd,OAAO,OACP,KAAK,yBACL;EAAW"}

package/dist/query.js

@@ -0,0 +1,371 @@
+//#region src/lib/query/query-ast.ts
+const EMPTY_QUERY = { clauses: [] };
+/** Whether a query constrains anything at all. */
+function isEmptyQuery(query) {
+	return !query || query.clauses.length === 0;
+}
+function sameClause(a, b) {
+	if (a.type !== b.type) return false;
+	if (a.type === "term" && b.type === "term") return a.value === b.value && a.negated === b.negated;
+	const fieldA = a;
+	const fieldB = b;
+	return fieldA.field === fieldB.field && fieldA.operator === fieldB.operator && fieldA.negated === fieldB.negated && fieldA.values.length === fieldB.values.length && fieldA.values.every((value, index) => value === fieldB.values[index]);
+}
+/** Add a clause unless an identical one is already there. */
+function addClause(query, clause) {
+	if (query.clauses.some((existing) => sameClause(existing, clause))) return query;
+	return { clauses: [...query.clauses, clause] };
+}
+/**
+* Constrain a field to a value — what a cell's "filter for this" action does.
+*
+* Applying the opposite of a constraint already present replaces it rather than
+* adding it: `status:200` then "filter out 200" should read as one changed
+* mind, not as a query that can never match.
+*/
+function withFieldValue(query, field, value, options = {}) {
+	var _options$negated, _options$operator;
+	const negated = (_options$negated = options.negated) !== null && _options$negated !== void 0 ? _options$negated : false;
+	const operator = (_options$operator = options.operator) !== null && _options$operator !== void 0 ? _options$operator : "eq";
+	return { clauses: [...query.clauses.filter((clause) => !(clause.type === "field" && clause.field === field && clause.operator === operator && clause.values.length === 1 && clause.values[0] === value)), {
+		type: "field",
+		field,
+		operator,
+		values: [value],
+		negated
+	}] };
+}
+/** Drop every clause naming `field`. */
+function withoutField(query, field) {
+	return { clauses: query.clauses.filter((clause) => clause.type !== "field" || clause.field !== field) };
+}
+/** Drop the clause at `index`, for a removable chip. */
+function removeClause(query, index) {
+	return { clauses: query.clauses.filter((_, at) => at !== index) };
+}
+/** Every field the query names, in the order they first appear. */
+function queryFields(query) {
+	const seen = [];
+	for (const clause of query.clauses) if (clause.type === "field" && !seen.includes(clause.field)) seen.push(clause.field);
+	return seen;
+}
+/** The values a field is constrained to, if any — for showing a filter as active. */
+function fieldValues(query, field) {
+	return query.clauses.flatMap((clause) => clause.type === "field" && clause.field === field && !clause.negated ? clause.values : []);
+}
+/**
+* Fold a cell action into the query.
+*
+* The pair of buttons on a log cell is the fastest path from "I noticed this
+* value" to a filtered view, and the reason it works is that the result is a
+* query the reader can then see, edit and share — not a hidden filter stack
+* with its own rules.
+*/
+function applyCellAction(query, action) {
+	return withFieldValue(query, action.field, action.value, { negated: action.intent === "exclude" });
+}
+//#endregion
+//#region src/lib/query/query-parse.ts
+const FIELD_NAME = /^[A-Za-z_][A-Za-z0-9_.-]*$/;
+/**
+* Split on whitespace, but keep quoted runs and parenthesised groups whole.
+*
+* An unterminated quote or group swallows the rest of the line rather than
+* erroring: the reader is mid-word, and the alternative is the query flickering
+* between two different meanings as they type the closing character.
+*/
+function tokenize(input) {
+	const tokens = [];
+	let index = 0;
+	while (index < input.length) {
+		while (index < input.length && /\s/.test(input[index])) index += 1;
+		if (index >= input.length) break;
+		const start = index;
+		let text = "";
+		let quoted = false;
+		let atTokenStart = true;
+		let depth = 0;
+		while (index < input.length) {
+			const char = input[index];
+			if (char === "\"") {
+				if (atTokenStart) quoted = true;
+				atTokenStart = false;
+				index += 1;
+				while (index < input.length && input[index] !== "\"") {
+					text += input[index];
+					index += 1;
+				}
+				index += 1;
+				continue;
+			}
+			if (char === "(") depth += 1;
+			if (char === ")") depth = Math.max(0, depth - 1);
+			if (/\s/.test(char) && depth === 0) break;
+			atTokenStart = false;
+			text += char;
+			index += 1;
+		}
+		if (text.length > 0 || quoted) tokens.push({
+			text,
+			at: start,
+			quoted
+		});
+	}
+	return tokens;
+}
+/** `(a or b)` → `["a", "b"]`; anything else is a single value. */
+function readValues(raw) {
+	const trimmed = raw.trim();
+	if (!trimmed.startsWith("(")) return [stripQuotes(trimmed)];
+	return trimmed.replace(/^\(/, "").replace(/\)$/, "").split(/\s+or\s+/i).map((part) => stripQuotes(part.trim())).filter((part) => part.length > 0);
+}
+function stripQuotes(value) {
+	if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+	return value.replace(/^"/, "");
+}
+const OPERATORS = [
+	{
+		symbol: ">=",
+		operator: "gte"
+	},
+	{
+		symbol: "<=",
+		operator: "lte"
+	},
+	{
+		symbol: ":",
+		operator: "eq"
+	},
+	{
+		symbol: ">",
+		operator: "gt"
+	},
+	{
+		symbol: "<",
+		operator: "lt"
+	}
+];
+/** Where a field operator starts in the token, or `-1`. */
+function findOperator(text) {
+	let best = null;
+	for (const { symbol, operator } of OPERATORS) {
+		const index = text.indexOf(symbol);
+		if (index <= 0) continue;
+		if (!best || index < best.index || index === best.index && symbol.length > best.symbol.length) best = {
+			index,
+			symbol,
+			operator
+		};
+	}
+	return best;
+}
+/** Parse, keeping whatever could not be understood as a plain term. */
+function parseQueryWithDiagnostics(input) {
+	const diagnostics = [];
+	const clauses = [];
+	let trailing = null;
+	for (const token of tokenize(input)) {
+		let text = token.text;
+		let negated = false;
+		if (!token.quoted && text.startsWith("-") && text.length > 1) {
+			negated = true;
+			text = text.slice(1);
+		}
+		const operator = token.quoted ? null : findOperator(text);
+		if (!operator) {
+			if (text.length > 0) clauses.push({
+				type: "term",
+				value: text,
+				negated
+			});
+			continue;
+		}
+		const field = text.slice(0, operator.index);
+		const rawValue = text.slice(operator.index + operator.symbol.length);
+		if (!FIELD_NAME.test(field)) {
+			clauses.push({
+				type: "term",
+				value: text,
+				negated
+			});
+			continue;
+		}
+		if (rawValue === "") {
+			trailing = {
+				field,
+				operator: operator.operator,
+				value: ""
+			};
+			continue;
+		}
+		if (rawValue === "*" && operator.operator === "eq") {
+			clauses.push({
+				type: "field",
+				field,
+				operator: "exists",
+				values: [],
+				negated
+			});
+			continue;
+		}
+		if (operator.operator === "eq" && rawValue.length > 2 && rawValue.startsWith("*") && rawValue.endsWith("*")) {
+			clauses.push({
+				type: "field",
+				field,
+				operator: "contains",
+				values: [stripQuotes(rawValue.slice(1, -1))],
+				negated
+			});
+			continue;
+		}
+		const values = readValues(rawValue);
+		if (values.length === 0) {
+			diagnostics.push({
+				at: token.at,
+				text: token.text,
+				message: "Empty value group"
+			});
+			continue;
+		}
+		if (operator.operator !== "eq" && values.length > 1) diagnostics.push({
+			at: token.at,
+			text: token.text,
+			message: "A comparison takes a single value"
+		});
+		const clause = {
+			type: "field",
+			field,
+			operator: operator.operator,
+			values: operator.operator === "eq" ? values : values.slice(0, 1),
+			negated
+		};
+		clauses.push(clause);
+		if (!rawValue.startsWith("(")) {
+			var _values$;
+			trailing = {
+				field,
+				operator: operator.operator,
+				value: (_values$ = values[0]) !== null && _values$ !== void 0 ? _values$ : ""
+			};
+		}
+	}
+	return {
+		query: { clauses },
+		diagnostics,
+		trailing
+	};
+}
+/** Parse, discarding diagnostics. */
+function parseQuery(input) {
+	return parseQueryWithDiagnostics(input).query;
+}
+//#endregion
+//#region src/lib/query/query-format.ts
+const OPERATOR_SYMBOL = {
+	eq: ":",
+	contains: ":",
+	gt: ">",
+	gte: ">=",
+	lt: "<",
+	lte: "<=",
+	exists: ":"
+};
+/** Quote a value that would otherwise re-parse as something else. */
+function quoteValue(value) {
+	return /[\s"()]/.test(value) || value === "" ? `"${value.replace(/"/g, "")}"` : value;
+}
+/** One clause as text. */
+function formatClause(clause) {
+	var _clause$values$2;
+	const prefix = clause.negated ? "-" : "";
+	if (clause.type === "term") return `${prefix}${quoteValue(clause.value)}`;
+	if (clause.operator === "exists") return `${prefix}${clause.field}:*`;
+	if (clause.operator === "contains") {
+		var _clause$values$;
+		return `${prefix}${clause.field}:*${(_clause$values$ = clause.values[0]) !== null && _clause$values$ !== void 0 ? _clause$values$ : ""}*`;
+	}
+	const symbol = OPERATOR_SYMBOL[clause.operator];
+	if (clause.values.length > 1) return `${prefix}${clause.field}${symbol}(${clause.values.map(quoteValue).join(" or ")})`;
+	return `${prefix}${clause.field}${symbol}${quoteValue((_clause$values$2 = clause.values[0]) !== null && _clause$values$2 !== void 0 ? _clause$values$2 : "")}`;
+}
+/** The whole query as text. */
+function formatQuery(query) {
+	return query.clauses.map(formatClause).join(" ");
+}
+/** A short human label for a clause chip. */
+function describeClause(clause) {
+	if (clause.type === "term") return clause.negated ? `not "${clause.value}"` : `"${clause.value}"`;
+	if (clause.operator === "exists") return clause.negated ? `${clause.field} missing` : `${clause.field} present`;
+	if (clause.operator === "contains") {
+		var _clause$values$3;
+		return `${clause.negated ? "not " : ""}${clause.field} ⊃ ${(_clause$values$3 = clause.values[0]) !== null && _clause$values$3 !== void 0 ? _clause$values$3 : ""}`;
+	}
+	const values = clause.values.join(", ");
+	const symbol = OPERATOR_SYMBOL[clause.operator];
+	return `${clause.negated ? "not " : ""}${clause.field} ${symbol === ":" ? "=" : symbol} ${values}`;
+}
+//#endregion
+//#region src/lib/query/query-match.ts
+function toText(value) {
+	if (value === null || value === void 0) return "";
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return JSON.stringify(value);
+}
+function compare(left, right) {
+	const leftNumber = typeof left === "number" ? left : Number(toText(left));
+	const rightNumber = Number(right);
+	if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) return leftNumber - rightNumber;
+	return toText(left).localeCompare(right);
+}
+function matchesClause(clause, read, searchable) {
+	if (clause.type === "term") return searchable().toLowerCase().includes(clause.value.toLowerCase());
+	const value = read(clause.field);
+	switch (clause.operator) {
+		case "exists": return value !== void 0 && value !== null && value !== "";
+		case "eq": return clause.values.some((candidate) => toText(value).toLowerCase() === candidate.toLowerCase());
+		case "contains": return clause.values.some((candidate) => toText(value).toLowerCase().includes(candidate.toLowerCase()));
+		case "gt":
+			var _clause$values$;
+			return compare(value, (_clause$values$ = clause.values[0]) !== null && _clause$values$ !== void 0 ? _clause$values$ : "") > 0;
+		case "gte":
+			var _clause$values$2;
+			return compare(value, (_clause$values$2 = clause.values[0]) !== null && _clause$values$2 !== void 0 ? _clause$values$2 : "") >= 0;
+		case "lt":
+			var _clause$values$3;
+			return compare(value, (_clause$values$3 = clause.values[0]) !== null && _clause$values$3 !== void 0 ? _clause$values$3 : "") < 0;
+		case "lte":
+			var _clause$values$4;
+			return compare(value, (_clause$values$4 = clause.values[0]) !== null && _clause$values$4 !== void 0 ? _clause$values$4 : "") <= 0;
+		default: return true;
+	}
+}
+/**
+* Whether one row satisfies every clause.
+*
+* `searchable` is lazy because most queries are field constraints, and
+* flattening a row to text for a term match nobody asked for is the expensive
+* part of filtering a live tail.
+*/
+function matchesQuery(query, read, searchable) {
+	return query.clauses.every((clause) => {
+		const matched = matchesClause(clause, read, searchable);
+		return clause.negated ? !matched : matched;
+	});
+}
+/** Convenience for plain objects, including one level of nested properties. */
+function matchesQueryObject(query, row, options = {}) {
+	const nested = options.nested ? row[options.nested] : void 0;
+	const read = (field) => field in row ? row[field] : nested === null || nested === void 0 ? void 0 : nested[field];
+	let cached = null;
+	const searchable = () => {
+		var _cached;
+		(_cached = cached) !== null && _cached !== void 0 || (cached = [...Object.values(row).filter((value) => typeof value !== "object"), ...Object.values(nested !== null && nested !== void 0 ? nested : {})].map(toText).join(" "));
+		return cached;
+	};
+	return matchesQuery(query, read, searchable);
+}
+//#endregion
+export { EMPTY_QUERY, addClause, applyCellAction, describeClause, fieldValues, formatClause, formatQuery, isEmptyQuery, matchesQuery, matchesQueryObject, parseQuery, parseQueryWithDiagnostics, queryFields, quoteValue, removeClause, withFieldValue, withoutField };
+
+//# sourceMappingURL=query.js.map