@reopt-ai/opt-ui 1.5.0 → 1.7.0

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

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","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"],"sourcesContent":["/**\n * A search query, as a value.\n *\n * Free-text search and a row of filter pickers answer different halves of the\n * same question, and neither can express the other: a picker cannot say \"not\n * this\", and a text box cannot say \"this field, exactly\". A parsed query is one\n * thing that does both, and — because it is a value rather than a widget's\n * internal state — it survives a URL, a saved view, and the trip to a server\n * that has to turn it into a database filter.\n *\n * The grammar follows the one analytics tools have converged on (Elastic's\n * `EuiSearchBar`, Kibana, GitHub's issue search), minus the parts that only\n * make sense against a Lucene index:\n *\n *   error                  a term anywhere in the row\n *   \"connection reset\"     a phrase, kept together\n *   -health                a term that must not appear\n *   path:/checkout         a field equal to a value\n *   path:(/a or /b)        a field equal to any of several values\n *   -status:200            a field that must not equal a value\n *   status>=500            a comparison\n *   path:*checkout*        the field contains this somewhere\n *   utm_source:*           the field is present at all\n *\n * Clauses combine with AND; `or` only groups values inside one field. That is\n * a deliberate ceiling: arbitrary boolean nesting reads worse than it queries,\n * and every backend this targets can express the restricted form directly.\n */\n\n/** How a field clause compares. */\nexport type QueryOperator =\n  | \"eq\"\n  | \"contains\"\n  | \"gt\"\n  | \"gte\"\n  | \"lt\"\n  | \"lte\"\n  | \"exists\";\n\n/** A bare or quoted word matched against the whole row. */\nexport interface QueryTermClause {\n  type: \"term\";\n  value: string;\n  negated: boolean;\n}\n\n/** A constraint on one named field. Several values read as \"any of\". */\nexport interface QueryFieldClause {\n  type: \"field\";\n  field: string;\n  operator: QueryOperator;\n  values: string[];\n  negated: boolean;\n}\n\nexport type QueryClause = QueryTermClause | QueryFieldClause;\n\n/** A parsed query: clauses combined with AND. */\nexport interface Query {\n  clauses: QueryClause[];\n}\n\nexport const EMPTY_QUERY: Query = { clauses: [] };\n\n/** Whether a query constrains anything at all. */\nexport function isEmptyQuery(query: Query | null | undefined): boolean {\n  return !query || query.clauses.length === 0;\n}\n\n/* ------------------------------------------------------------------ */\n/*  Editing                                                            */\n/* ------------------------------------------------------------------ */\n\nfunction sameClause(a: QueryClause, b: QueryClause): boolean {\n  if (a.type !== b.type) return false;\n  if (a.type === \"term\" && b.type === \"term\") {\n    return a.value === b.value && a.negated === b.negated;\n  }\n  const fieldA = a as QueryFieldClause;\n  const fieldB = b as QueryFieldClause;\n  return (\n    fieldA.field === fieldB.field &&\n    fieldA.operator === fieldB.operator &&\n    fieldA.negated === fieldB.negated &&\n    fieldA.values.length === fieldB.values.length &&\n    fieldA.values.every((value, index) => value === fieldB.values[index])\n  );\n}\n\n/** Add a clause unless an identical one is already there. */\nexport function addClause(query: Query, clause: QueryClause): Query {\n  if (query.clauses.some((existing) => sameClause(existing, clause))) {\n    return query;\n  }\n  return { clauses: [...query.clauses, clause] };\n}\n\n/**\n * Constrain a field to a value — what a cell's \"filter for this\" action does.\n *\n * Applying the opposite of a constraint already present replaces it rather than\n * adding it: `status:200` then \"filter out 200\" should read as one changed\n * mind, not as a query that can never match.\n */\nexport function withFieldValue(\n  query: Query,\n  field: string,\n  value: string,\n  options: { negated?: boolean; operator?: QueryOperator } = {},\n): Query {\n  const negated = options.negated ?? false;\n  const operator = options.operator ?? \"eq\";\n  const clauses = query.clauses.filter(\n    (clause) =>\n      !(\n        clause.type === \"field\" &&\n        clause.field === field &&\n        clause.operator === operator &&\n        clause.values.length === 1 &&\n        clause.values[0] === value\n      ),\n  );\n  return {\n    clauses: [\n      ...clauses,\n      { type: \"field\", field, operator, values: [value], negated },\n    ],\n  };\n}\n\n/** Drop every clause naming `field`. */\nexport function withoutField(query: Query, field: string): Query {\n  return {\n    clauses: query.clauses.filter(\n      (clause) => clause.type !== \"field\" || clause.field !== field,\n    ),\n  };\n}\n\n/** Drop the clause at `index`, for a removable chip. */\nexport function removeClause(query: Query, index: number): Query {\n  return { clauses: query.clauses.filter((_, at) => at !== index) };\n}\n\n/** Every field the query names, in the order they first appear. */\nexport function queryFields(query: Query): string[] {\n  const seen: string[] = [];\n  for (const clause of query.clauses) {\n    if (clause.type === \"field\" && !seen.includes(clause.field)) {\n      seen.push(clause.field);\n    }\n  }\n  return seen;\n}\n\n/** The values a field is constrained to, if any — for showing a filter as active. */\nexport function fieldValues(query: Query, field: string): string[] {\n  return query.clauses.flatMap((clause) =>\n    clause.type === \"field\" && clause.field === field && !clause.negated\n      ? clause.values\n      : [],\n  );\n}\n\n/* ------------------------------------------------------------------ */\n/*  Cell actions                                                       */\n/* ------------------------------------------------------------------ */\n\n/** What a \"filter for / filter out\" control on a value asks for. */\nexport interface QueryCellAction {\n  field: string;\n  value: string;\n  intent: \"include\" | \"exclude\";\n}\n\n/**\n * Fold a cell action into the query.\n *\n * The pair of buttons on a log cell is the fastest path from \"I noticed this\n * value\" to a filtered view, and the reason it works is that the result is a\n * query the reader can then see, edit and share — not a hidden filter stack\n * with its own rules.\n */\nexport function applyCellAction(query: Query, action: QueryCellAction): Query {\n  return withFieldValue(query, action.field, action.value, {\n    negated: action.intent === \"exclude\",\n  });\n}\n","/**\n * Text in, {@link Query} out — and never an exception.\n *\n * A search box is edited one keystroke at a time, so most of the strings this\n * sees are half-written: `path:`, `status>`, `\"unclosed`. A parser that throws\n * on those turns every intermediate state into an error banner, which trains\n * people to type somewhere else and paste. Instead, anything that cannot be\n * read as a clause is kept as a plain term, and the caller is told separately\n * (via {@link parseQueryWithDiagnostics}) if it wants to warn.\n *\n * Written by hand rather than generated. EUI compiles a PEG grammar for the\n * same job, which buys arbitrary nesting we deliberately do not offer, at the\n * cost of a build-time plugin in every consumer.\n */\nimport type {\n  Query,\n  QueryClause,\n  QueryFieldClause,\n  QueryOperator,\n} from \"./query-ast\";\n\n/** A part of the input that could not be read as intended. */\nexport interface QueryDiagnostic {\n  /** Character offset into the original string. */\n  at: number;\n  text: string;\n  message: string;\n}\n\nexport interface ParsedQuery {\n  query: Query;\n  diagnostics: QueryDiagnostic[];\n  /** The final clause is still being typed — the caller can complete it. */\n  trailing: { field: string; operator: QueryOperator; value: string } | null;\n}\n\nconst FIELD_NAME = /^[A-Za-z_][A-Za-z0-9_.-]*$/;\n\ninterface Token {\n  text: string;\n  at: number;\n  /** The token was written inside quotes, so it is a phrase, not syntax. */\n  quoted: boolean;\n}\n\n/**\n * Split on whitespace, but keep quoted runs and parenthesised groups whole.\n *\n * An unterminated quote or group swallows the rest of the line rather than\n * erroring: the reader is mid-word, and the alternative is the query flickering\n * between two different meanings as they type the closing character.\n */\nfunction tokenize(input: string): Token[] {\n  const tokens: Token[] = [];\n  let index = 0;\n\n  while (index < input.length) {\n    while (index < input.length && /\\s/.test(input[index]!)) index += 1;\n    if (index >= input.length) break;\n\n    const start = index;\n    let text = \"\";\n    // Only a token that *opens* with a quote is a phrase. `name:\"a b\"` quotes\n    // its value, not the constraint — reading the whole token as a phrase there\n    // would turn a field filter into a search for the literal text.\n    let quoted = false;\n    let atTokenStart = true;\n    let depth = 0;\n\n    while (index < input.length) {\n      const char = input[index]!;\n\n      if (char === '\"') {\n        if (atTokenStart) quoted = true;\n        atTokenStart = false;\n        index += 1;\n        while (index < input.length && input[index] !== '\"') {\n          text += input[index];\n          index += 1;\n        }\n        index += 1; // closing quote, or the end of the input\n        continue;\n      }\n\n      if (char === \"(\") depth += 1;\n      if (char === \")\") depth = Math.max(0, depth - 1);\n      if (/\\s/.test(char) && depth === 0) break;\n\n      atTokenStart = false;\n      text += char;\n      index += 1;\n    }\n\n    if (text.length > 0 || quoted) tokens.push({ text, at: start, quoted });\n  }\n\n  return tokens;\n}\n\n/** `(a or b)` → `[\"a\", \"b\"]`; anything else is a single value. */\nfunction readValues(raw: string): string[] {\n  const trimmed = raw.trim();\n  if (!trimmed.startsWith(\"(\")) {\n    return [stripQuotes(trimmed)];\n  }\n  const inner = trimmed.replace(/^\\(/, \"\").replace(/\\)$/, \"\");\n  return inner\n    .split(/\\s+or\\s+/i)\n    .map((part) => stripQuotes(part.trim()))\n    .filter((part) => part.length > 0);\n}\n\nfunction stripQuotes(value: string): string {\n  if (value.length >= 2 && value.startsWith('\"') && value.endsWith('\"')) {\n    return value.slice(1, -1);\n  }\n  return value.replace(/^\"/, \"\");\n}\n\nconst OPERATORS: { symbol: string; operator: QueryOperator }[] = [\n  { symbol: \">=\", operator: \"gte\" },\n  { symbol: \"<=\", operator: \"lte\" },\n  { symbol: \":\", operator: \"eq\" },\n  { symbol: \">\", operator: \"gt\" },\n  { symbol: \"<\", operator: \"lt\" },\n];\n\n/** Where a field operator starts in the token, or `-1`. */\nfunction findOperator(\n  text: string,\n): { index: number; symbol: string; operator: QueryOperator } | null {\n  let best: { index: number; symbol: string; operator: QueryOperator } | null =\n    null;\n  for (const { symbol, operator } of OPERATORS) {\n    const index = text.indexOf(symbol);\n    if (index <= 0) continue;\n    // `>=` must win over the `>` inside it.\n    if (\n      !best ||\n      index < best.index ||\n      (index === best.index && symbol.length > best.symbol.length)\n    ) {\n      best = { index, symbol, operator };\n    }\n  }\n  return best;\n}\n\n/** Parse, keeping whatever could not be understood as a plain term. */\nexport function parseQueryWithDiagnostics(input: string): ParsedQuery {\n  const diagnostics: QueryDiagnostic[] = [];\n  const clauses: QueryClause[] = [];\n  let trailing: ParsedQuery[\"trailing\"] = null;\n\n  for (const token of tokenize(input)) {\n    let text = token.text;\n    let negated = false;\n\n    if (!token.quoted && text.startsWith(\"-\") && text.length > 1) {\n      negated = true;\n      text = text.slice(1);\n    }\n\n    const operator = token.quoted ? null : findOperator(text);\n    if (!operator) {\n      if (text.length > 0) clauses.push({ type: \"term\", value: text, negated });\n      continue;\n    }\n\n    const field = text.slice(0, operator.index);\n    const rawValue = text.slice(operator.index + operator.symbol.length);\n\n    if (!FIELD_NAME.test(field)) {\n      // `12:30` is a time, not a field constraint.\n      clauses.push({ type: \"term\", value: text, negated });\n      continue;\n    }\n\n    if (rawValue === \"\") {\n      // Mid-typing: remember it so the caller can offer completions, but do not\n      // constrain anything yet — an empty value would match nothing.\n      trailing = { field, operator: operator.operator, value: \"\" };\n      continue;\n    }\n\n    if (rawValue === \"*\" && operator.operator === \"eq\") {\n      clauses.push({\n        type: \"field\",\n        field,\n        operator: \"exists\",\n        values: [],\n        negated,\n      });\n      continue;\n    }\n\n    // `path:*checkout*` — the wildcards are the syntax, the middle is the value.\n    // Distinct from a bare `*`, which asks whether the field is there at all.\n    if (\n      operator.operator === \"eq\" &&\n      rawValue.length > 2 &&\n      rawValue.startsWith(\"*\") &&\n      rawValue.endsWith(\"*\")\n    ) {\n      clauses.push({\n        type: \"field\",\n        field,\n        operator: \"contains\",\n        values: [stripQuotes(rawValue.slice(1, -1))],\n        negated,\n      });\n      continue;\n    }\n\n    const values = readValues(rawValue);\n    if (values.length === 0) {\n      diagnostics.push({\n        at: token.at,\n        text: token.text,\n        message: \"Empty value group\",\n      });\n      continue;\n    }\n\n    if (operator.operator !== \"eq\" && values.length > 1) {\n      diagnostics.push({\n        at: token.at,\n        text: token.text,\n        message: \"A comparison takes a single value\",\n      });\n    }\n\n    const clause: QueryFieldClause = {\n      type: \"field\",\n      field,\n      operator: operator.operator,\n      values: operator.operator === \"eq\" ? values : values.slice(0, 1),\n      negated,\n    };\n    clauses.push(clause);\n    if (!rawValue.startsWith(\"(\")) {\n      trailing = { field, operator: operator.operator, value: values[0] ?? \"\" };\n    }\n  }\n\n  return { query: { clauses }, diagnostics, trailing };\n}\n\n/** Parse, discarding diagnostics. */\nexport function parseQuery(input: string): Query {\n  return parseQueryWithDiagnostics(input).query;\n}\n","/**\n * {@link Query} back to text, so the box shows what the chips mean.\n *\n * Round-tripping matters more than prettiness: whatever a cell action or a\n * sidebar click adds to the query has to appear in the input as something the\n * reader could have typed themselves, and could edit by hand from there.\n */\nimport type { Query, QueryClause, QueryOperator } from \"./query-ast\";\n\nconst OPERATOR_SYMBOL: Record<QueryOperator, string> = {\n  eq: \":\",\n  contains: \":\",\n  gt: \">\",\n  gte: \">=\",\n  lt: \"<\",\n  lte: \"<=\",\n  exists: \":\",\n};\n\n/** Quote a value that would otherwise re-parse as something else. */\nexport function quoteValue(value: string): string {\n  return /[\\s\"()]/.test(value) || value === \"\"\n    ? `\"${value.replace(/\"/g, \"\")}\"`\n    : value;\n}\n\n/** One clause as text. */\nexport function formatClause(clause: QueryClause): string {\n  const prefix = clause.negated ? \"-\" : \"\";\n  if (clause.type === \"term\") return `${prefix}${quoteValue(clause.value)}`;\n  if (clause.operator === \"exists\") return `${prefix}${clause.field}:*`;\n  if (clause.operator === \"contains\") {\n    return `${prefix}${clause.field}:*${clause.values[0] ?? \"\"}*`;\n  }\n\n  const symbol = OPERATOR_SYMBOL[clause.operator];\n  if (clause.values.length > 1) {\n    return `${prefix}${clause.field}${symbol}(${clause.values.map(quoteValue).join(\" or \")})`;\n  }\n  return `${prefix}${clause.field}${symbol}${quoteValue(clause.values[0] ?? \"\")}`;\n}\n\n/** The whole query as text. */\nexport function formatQuery(query: Query): string {\n  return query.clauses.map(formatClause).join(\" \");\n}\n\n/** A short human label for a clause chip. */\nexport function describeClause(clause: QueryClause): string {\n  if (clause.type === \"term\") {\n    return clause.negated ? `not \"${clause.value}\"` : `\"${clause.value}\"`;\n  }\n  if (clause.operator === \"exists\") {\n    return clause.negated\n      ? `${clause.field} missing`\n      : `${clause.field} present`;\n  }\n  if (clause.operator === \"contains\") {\n    return `${clause.negated ? \"not \" : \"\"}${clause.field} ⊃ ${clause.values[0] ?? \"\"}`;\n  }\n  const values = clause.values.join(\", \");\n  const symbol = OPERATOR_SYMBOL[clause.operator];\n  return `${clause.negated ? \"not \" : \"\"}${clause.field} ${symbol === \":\" ? \"=\" : symbol} ${values}`;\n}\n","/**\n * Run a {@link Query} against rows already in the browser.\n *\n * The server does the real filtering; this exists for the cases where asking it\n * would be worse than answering locally — live rows arriving over a socket that\n * must be held to the same filter as the page they land on, and a preview of\n * what a clause will do before it is committed.\n *\n * Keeping both readings in one module is the point: a query that means one\n * thing in the list and another in the live tail is a bug nobody reports,\n * because each half looks right on its own.\n */\nimport type { Query, QueryClause } from \"./query-ast\";\n\n/** How a row exposes its values. Missing fields return `undefined`. */\nexport type FieldReader = (field: string) => unknown;\n\nfunction toText(value: unknown): string {\n  if (value === null || value === undefined) return \"\";\n  if (typeof value === \"string\") return value;\n  if (typeof value === \"number\" || typeof value === \"boolean\")\n    return String(value);\n  return JSON.stringify(value);\n}\n\nfunction compare(left: unknown, right: string): number {\n  const leftNumber = typeof left === \"number\" ? left : Number(toText(left));\n  const rightNumber = Number(right);\n  if (Number.isFinite(leftNumber) && Number.isFinite(rightNumber)) {\n    return leftNumber - rightNumber;\n  }\n  return toText(left).localeCompare(right);\n}\n\nfunction matchesClause(\n  clause: QueryClause,\n  read: FieldReader,\n  searchable: () => string,\n): boolean {\n  if (clause.type === \"term\") {\n    return searchable().toLowerCase().includes(clause.value.toLowerCase());\n  }\n\n  const value = read(clause.field);\n\n  switch (clause.operator) {\n    case \"exists\":\n      return value !== undefined && value !== null && value !== \"\";\n    case \"eq\":\n      // Case-insensitive: a log reader typing `path:/Checkout` means the path.\n      return clause.values.some(\n        (candidate) => toText(value).toLowerCase() === candidate.toLowerCase(),\n      );\n    case \"contains\":\n      return clause.values.some((candidate) =>\n        toText(value).toLowerCase().includes(candidate.toLowerCase()),\n      );\n    case \"gt\":\n      return compare(value, clause.values[0] ?? \"\") > 0;\n    case \"gte\":\n      return compare(value, clause.values[0] ?? \"\") >= 0;\n    case \"lt\":\n      return compare(value, clause.values[0] ?? \"\") < 0;\n    case \"lte\":\n      return compare(value, clause.values[0] ?? \"\") <= 0;\n    default:\n      return true;\n  }\n}\n\n/**\n * Whether one row satisfies every clause.\n *\n * `searchable` is lazy because most queries are field constraints, and\n * flattening a row to text for a term match nobody asked for is the expensive\n * part of filtering a live tail.\n */\nexport function matchesQuery(\n  query: Query,\n  read: FieldReader,\n  searchable: () => string,\n): boolean {\n  return query.clauses.every((clause) => {\n    const matched = matchesClause(clause, read, searchable);\n    return clause.negated ? !matched : matched;\n  });\n}\n\n/** Convenience for plain objects, including one level of nested properties. */\nexport function matchesQueryObject(\n  query: Query,\n  row: Record<string, unknown>,\n  options: { nested?: string } = {},\n): boolean {\n  const nested = options.nested\n    ? (row[options.nested] as Record<string, unknown> | undefined)\n    : undefined;\n  const read: FieldReader = (field) =>\n    field in row ? row[field] : nested?.[field];\n  let cached: string | null = null;\n  const searchable = () => {\n    cached ??= [\n      ...Object.values(row).filter((value) => typeof value !== \"object\"),\n      ...Object.values(nested ?? {}),\n    ]\n      .map(toText)\n      .join(\" \");\n    return cached;\n  };\n  return matchesQuery(query, read, searchable);\n}\n"],"mappings":"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"}