@tellaro/tql 1.3.8 → 1.4.1

package/dist/src/completionProvider.js

@@ -1,4 +1,4 @@
-import { tokenizeTql as x, COMPARISON_OPERATORS as N, LOGICAL_OPERATORS as I, AGGREGATION_FUNCTIONS as S, VISUALIZATION_TYPES as A, TYPE_HINTS as L, MUTATORS as R } from "./tokenizer.js";
+import { tokenizeTql as x, COMPARISON_OPERATORS as S, LOGICAL_OPERATORS as N, AGGREGATION_FUNCTIONS as I, VISUALIZATION_TYPES as L, TYPE_HINTS as A, MUTATORS as R } from "./tokenizer.js";
 import { fuzzyMatch as w } from "./fuzzyMatcher.js";
 import { getSchemaCache as $ } from "./schemaCache.js";
 const P = [
@@ -167,7 +167,7 @@ const P = [
   sum: { detail: "Sum", documentation: "Sum of numeric array elements" },
   min: { detail: "Minimum", documentation: "Minimum value in array" },
   max: { detail: "Maximum", documentation: "Maximum value in array" }
-}, g = {
+}, h = {
   // String outputs
   lowercase: "keyword",
   uppercase: "keyword",
@@ -201,7 +201,7 @@ const P = [
   geo: "object",
   // Array output (returns array of strings)
   split: "keyword"
-}, E = {
+}, z = {
   // Universal operators (work with all types)
   eq: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
   ne: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
@@ -238,186 +238,267 @@ const P = [
   all: ["nested", "object", "keyword"],
   none: ["nested", "object", "keyword"]
 };
-class U {
+class E {
   cache = /* @__PURE__ */ new Map();
   maxSize = 50;
   maxAge = 5e3;
   // 5 seconds
   get(t) {
-    const a = this.cache.get(t);
-    if (a && Date.now() - a.timestamp < this.maxAge)
-      return a.result;
-    a && this.cache.delete(t);
+    const i = this.cache.get(t);
+    if (i && Date.now() - i.timestamp < this.maxAge)
+      return i.result;
+    i && this.cache.delete(t);
   }
-  set(t, a) {
+  set(t, i) {
     if (this.cache.size >= this.maxSize) {
-      const i = this.cache.keys().next().value;
-      i && this.cache.delete(i);
+      const o = this.cache.keys().next().value;
+      o && this.cache.delete(o);
     }
-    this.cache.set(t, { result: a, timestamp: Date.now() });
+    this.cache.set(t, { result: i, timestamp: Date.now() });
   }
   clear() {
     this.cache.clear();
   }
 }
-const v = new U();
-function z(e, t, a) {
-  const i = `${e.substring(0, t)}|${t}`, o = v.get(i);
-  if (o)
-    return o.fieldName && !o.fieldType && a && (o.fieldType = p(o.fieldName, a)), o;
-  const n = F(e, t, a);
-  return v.set(i, n), n;
+const v = new E();
+function U(e, t, i) {
+  if (!e) return { type: "start", partialText: "" };
+  const o = `${e.substring(0, t)}|${t}`, a = v.get(o);
+  if (a)
+    return a.fieldName && !a.fieldType && i && (a.fieldType = p(a.fieldName, i)), a;
+  const n = F(e, t, i);
+  return v.set(o, n), n;
 }
-function F(e, t, a) {
-  const o = x(e.substring(0, t)).filter((r) => r.type !== "whitespace");
-  if (o.length === 0)
+function F(e, t, i) {
+  const a = x(e.substring(0, t)).filter((l) => l.type !== "whitespace");
+  if (a.length === 0)
     return { type: "start" };
-  const n = o[o.length - 1], s = o.length > 1 ? o[o.length - 2] : null, d = n.end === t && !e[t - 1]?.match(/\s/), l = d ? n.value : void 0;
+  const n = a[a.length - 1], s = a.length > 1 ? a[a.length - 2] : null, u = n.end === t && !e[t - 1]?.match(/\s/), d = u ? n.value : void 0;
   if (n.type === "logicalOp")
     return { type: "start" };
+  if (n.type === "paren" && n.value === "(") {
+    const l = a.length - 1, r = l > 0 ? a[l - 1] : null;
+    if (r && r.type === "visualization")
+      return { type: "in_viz_params" };
+  }
+  if (n.type === "comma" || n.type === "field" && u) {
+    const l = a.indexOf(n);
+    for (let r = l - 1; r >= 0; r--) {
+      if (a[r].type === "paren" && a[r].value === "(") {
+        if (r > 0 && a[r - 1].type === "visualization")
+          return { type: "in_viz_params", partialText: d };
+        break;
+      }
+      if (a[r].type === "paren" && a[r].value === ")") break;
+    }
+  }
   if (n.type === "paren" && n.value === "(")
     return { type: "after_paren" };
   if (n.type === "arrow")
-    return { type: "after_arrow", partialText: l };
+    return { type: "after_arrow", partialText: d };
   if (n.type === "doubleColon")
-    return { type: "after_double_colon", partialText: l };
-  if (n.type === "visualization" && d)
-    return { type: "after_arrow", partialText: l };
-  if (n.type === "typeHint" && d)
-    return { type: "after_double_colon", partialText: l };
+    return { type: "after_double_colon", partialText: d };
+  if (n.type === "visualization" && u)
+    return { type: "after_arrow", partialText: d };
+  if (n.type === "typeHint" && u)
+    return { type: "after_double_colon", partialText: d };
   if (n.type === "keyword" && n.value.toLowerCase() === "stats")
-    return { type: "after_stats", partialText: l };
+    return { type: "after_stats", partialText: d };
   if (n.type === "keyword" && n.value.toLowerCase() === "by")
-    return { type: "after_by", partialText: l };
+    return { type: "after_by", partialText: d };
+  if (n.type === "paren" && n.value === ")") {
+    const l = a.indexOf(n);
+    for (let r = l - 1; r >= 0; r--) {
+      if (a[r].type === "keyword" && a[r].value.toLowerCase() === "stats")
+        return { type: "after_stats_agg" };
+      if (a[r].type === "keyword" && a[r].value.toLowerCase() === "by" || a[r].type === "pipe") break;
+    }
+  }
+  if (n.type === "field" && !u) {
+    const l = a.indexOf(n);
+    for (let r = l - 1; r >= 0; r--) {
+      if (a[r].type === "keyword" && a[r].value.toLowerCase() === "by") {
+        for (let c = r - 1; c >= 0; c--) {
+          if (a[c].type === "keyword" && a[c].value.toLowerCase() === "stats")
+            return { type: "after_group_by_field" };
+          if (a[c].type === "pipe") break;
+        }
+        break;
+      }
+      if (a[r].type === "pipe") break;
+    }
+  }
   if (n.type === "pipe")
-    return { type: "after_pipe", partialText: l };
+    return { type: "after_pipe", partialText: d };
   if (n.type === "mutator") {
-    if (d)
-      return { type: "after_pipe", partialText: l };
-    const r = n.value.toLowerCase(), c = g[r];
+    if (u)
+      return { type: "after_pipe", partialText: d };
+    const l = n.value.toLowerCase(), r = h[l];
     return {
       type: "after_mutator",
-      mutatorName: r,
-      mutatorOutputType: c
+      mutatorName: l,
+      mutatorOutputType: r
     };
   }
   if (n.type === "aggregation")
-    return d ? { type: "after_stats", partialText: l } : { type: "after_value" };
+    return u ? { type: "after_stats", partialText: d } : { type: "after_value" };
   if (n.type === "field") {
-    if (d)
-      return s?.type === "pipe" ? { type: "after_pipe", partialText: l } : { type: "start", partialText: l };
+    if (u)
+      return s?.type === "pipe" ? { type: "after_pipe", partialText: d } : { type: "start", partialText: d };
     if (s?.type === "pipe")
       return { type: "after_pipe", partialText: n.value };
-    const r = p(n.value, a);
-    return { type: "after_field", fieldName: n.value, fieldType: r };
+    const l = p(n.value, i);
+    return { type: "after_field", fieldName: n.value, fieldType: l };
   }
   if (n.type === "operator") {
-    if (d) {
+    if (u) {
       if (s?.type === "field") {
-        const r = p(s.value, a);
-        return { type: "after_field", fieldName: s.value, fieldType: r, partialText: l };
+        const l = p(s.value, i);
+        return { type: "after_field", fieldName: s.value, fieldType: l, partialText: d };
       }
       if (s?.type === "mutator") {
-        const r = s.value.toLowerCase(), c = g[r];
-        return { type: "after_mutator", mutatorName: r, mutatorOutputType: c, partialText: l };
+        const l = s.value.toLowerCase(), r = h[l];
+        return { type: "after_mutator", mutatorName: l, mutatorOutputType: r, partialText: d };
       }
     }
     return { type: "after_operator", operatorName: n.value };
   }
   if (n.type === "string" || n.type === "number" || n.type === "boolean" || n.type === "null")
-    return d ? { type: "at_value_end" } : { type: "after_value" };
+    return u ? { type: "at_value_end" } : { type: "after_value" };
   if (n.type === "paren" && n.value === ")")
     return { type: "after_value" };
-  if (s?.type === "field" && d) {
-    const r = p(s.value, a);
-    return { type: "after_field", fieldName: s.value, fieldType: r, partialText: l };
+  if (s?.type === "field" && u) {
+    const l = p(s.value, i);
+    return { type: "after_field", fieldName: s.value, fieldType: l, partialText: d };
   }
-  if (s?.type === "mutator" && d) {
-    const r = s.value.toLowerCase(), c = g[r];
-    return { type: "after_mutator", mutatorName: r, mutatorOutputType: c, partialText: l };
+  if (s?.type === "mutator" && u) {
+    const l = s.value.toLowerCase(), r = h[l];
+    return { type: "after_mutator", mutatorName: l, mutatorOutputType: r, partialText: d };
   }
-  return { type: "unknown", partialText: l };
+  return { type: "unknown", partialText: d };
 }
 function p(e, t) {
   return t ? $().getFieldType(t, e) : void 0;
 }
-function J(e, t = {}) {
-  const { query: a, cursorPosition: i } = e, o = z(a, i, t.fields), n = [];
-  switch (o.type) {
+function Q(e, t = {}) {
+  const { query: i, cursorPosition: o } = e;
+  if (!i) return [];
+  const a = U(i, o, t.fields), n = [];
+  switch (a.type) {
     case "start":
     case "after_paren":
-      n.push(...h(t.fields, o.partialText)), n.push(O("NOT")), t.includeSnippets !== !1 && n.push(...V(t, o.partialText));
+      n.push(...g(t.fields, a.partialText)), n.push(O("NOT")), t.includeSnippets !== !1 && n.push(...B(t, a.partialText));
       break;
     case "after_field":
-      n.push(...y(o.partialText, o.fieldType));
+      n.push(...y(a.partialText, a.fieldType));
       break;
     case "after_mutator":
-      n.push(...y(o.partialText, o.mutatorOutputType));
+      n.push(...y(a.partialText, a.mutatorOutputType));
       break;
     case "after_operator":
-      n.push(...G(o.fieldName, t));
+      n.push(...j(a.fieldName, t));
       break;
     case "after_value":
-      n.push(...T());
+      n.push(..._());
       break;
     case "at_value_end":
       break;
     case "after_pipe":
-      n.push(...j(o.partialText));
+      n.push(...V(a.partialText)), (!a.partialText || "stats".includes(a.partialText.toLowerCase())) && n.push({
+        label: "stats",
+        insertText: "stats ",
+        kind: "keyword",
+        detail: "Aggregate data with stats functions (count, sum, avg, ...)",
+        sortOrder: 1
+        // Top of list
+      });
+      break;
+    case "after_stats_agg":
+      n.push({
+        label: "by",
+        insertText: "by ",
+        kind: "keyword",
+        detail: "Group results by field",
+        sortOrder: 1
+      }), n.push({
+        label: "=>",
+        insertText: "=> ",
+        kind: "visualization",
+        detail: "Set visualization type (bar, pie, line, ...)",
+        sortOrder: 2
+      });
+      break;
+    case "after_group_by_field":
+      n.push({
+        label: "=>",
+        insertText: "=> ",
+        kind: "visualization",
+        detail: "Set visualization type (bar, pie, line, ...)",
+        sortOrder: 1
+      }), n.push({
+        label: ",",
+        insertText: ", ",
+        kind: "keyword",
+        detail: "Add another group-by field",
+        sortOrder: 2
+      });
       break;
     case "after_double_colon":
-      n.push(...H(o.partialText));
+      n.push(...H(a.partialText));
       break;
     case "after_arrow":
-      n.push(...Y(o.partialText));
+      n.push(...Y(a.partialText));
+      break;
+    case "in_viz_params":
+      n.push(...W(a.partialText));
       break;
     case "after_stats":
-      n.push(...C(o.partialText));
+      n.push(...C(a.partialText));
       break;
     case "after_by":
-      n.push(...h(t.fields, o.partialText));
+      n.push(...g(t.fields, a.partialText));
       break;
     default:
-      n.push(...h(t.fields, o.partialText)), n.push(...y(o.partialText)), n.push(...T());
+      n.push(...g(t.fields, a.partialText)), n.push(...y(a.partialText)), n.push(..._());
   }
-  t.includeAggregations && o.type === "start" && n.push(...C(o.partialText));
+  t.includeAggregations && a.type === "start" && n.push(...C(a.partialText));
   let s = n;
-  const d = t.fuzzyMatching !== !1, l = t.minFuzzyScore ?? 0;
-  if (o.partialText) {
-    const r = o.partialText.toLowerCase();
-    if (d) {
-      const c = [];
-      for (const u of n) {
-        const m = w(r, u.label), b = u.filterText ? w(r, u.filterText) : { matched: !1, score: 0 }, f = m.score >= b.score ? m : b;
-        f.matched && f.score >= l && c.push({
-          ...u,
+  const u = t.fuzzyMatching !== !1, d = t.minFuzzyScore ?? 0;
+  if (a.partialText) {
+    const l = a.partialText.toLowerCase();
+    if (u) {
+      const r = [];
+      for (const c of n) {
+        const m = w(l, c.label), b = c.filterText ? w(l, c.filterText) : { matched: !1, score: 0 }, f = m.score >= b.score ? m : b;
+        f.matched && f.score >= d && r.push({
+          ...c,
           matchScore: f.score,
           matchedIndices: m.matched ? m.matchedIndices : void 0
         });
       }
-      s = c;
+      s = r;
     } else
       s = n.filter(
-        (c) => c.label.toLowerCase().includes(r) || c.filterText?.toLowerCase().includes(r)
+        (r) => r.label.toLowerCase().includes(l) || r.filterText?.toLowerCase().includes(l)
       );
   }
-  return s.sort((r, c) => r.matchScore !== void 0 && c.matchScore !== void 0 && c.matchScore !== r.matchScore ? c.matchScore - r.matchScore : r.sortOrder - c.sortOrder), t.maxItems && t.maxItems > 0 && (s = s.slice(0, t.maxItems)), s;
+  return s.sort((l, r) => l.matchScore !== void 0 && r.matchScore !== void 0 && r.matchScore !== l.matchScore ? r.matchScore - l.matchScore : l.sortOrder - r.sortOrder), t.maxItems && t.maxItems > 0 && (s = s.slice(0, t.maxItems)), s;
 }
-function h(e, t) {
+function g(e, t) {
   if (!e || e.length === 0)
-    return q(t);
-  const a = [];
-  for (const i of e) {
-    const o = k(i);
-    if (a.push(o), i.nested)
-      for (const n of i.nested) {
-        const s = k(n, i.name);
-        a.push(s);
+    return G(t);
+  const i = [];
+  for (const o of e) {
+    const a = k(o);
+    if (i.push(a), o.nested)
+      for (const n of o.nested) {
+        const s = k(n, o.name);
+        i.push(s);
       }
   }
-  return a;
+  return i;
 }
-function q(e) {
+function G(e) {
   return [
     { name: "hostname", description: "Host/machine name" },
     { name: "status", description: "Status value" },
@@ -434,20 +515,20 @@ function q(e) {
     { name: "os.version", description: "Operating system version" },
     { name: "customer", description: "Customer identifier" },
     { name: "stack", description: "Stack identifier" }
-  ].filter((a) => !e || a.name.toLowerCase().includes(e.toLowerCase())).map((a) => ({
-    label: a.name,
-    insertText: a.name + " ",
+  ].filter((i) => !e || i.name.toLowerCase().includes(e.toLowerCase())).map((i) => ({
+    label: i.name,
+    insertText: i.name + " ",
     // Add trailing space for easier operator typing
     kind: "field",
-    detail: a.description,
+    detail: i.description,
     sortOrder: 10
   }));
 }
 function k(e, t) {
-  const a = t ? `${t}.${e.name}` : e.name;
+  const i = t ? `${t}.${e.name}` : e.name;
   return {
-    label: a,
-    insertText: a + " ",
+    label: i,
+    insertText: i + " ",
     // Add trailing space for easier operator typing
     kind: "field",
     detail: e.description || `Type: ${e.type}`,
@@ -456,24 +537,24 @@ function k(e, t) {
   };
 }
 function y(e, t) {
-  let a = [...N];
-  return t && (a = a.filter((i) => {
-    const o = E[i];
-    return !o || o.includes(t);
-  })), e && (a = a.filter((i) => i.toLowerCase().includes(e.toLowerCase()))), a.map((i, o) => {
-    const n = D[i] || { detail: i, documentation: "" }, s = B(i, t);
+  let i = [...S];
+  return t && (i = i.filter((o) => {
+    const a = z[o];
+    return !a || a.includes(t);
+  })), e && (i = i.filter((o) => o.toLowerCase().includes(e.toLowerCase()))), i.map((o, a) => {
+    const n = D[o] || { detail: o, documentation: "" }, s = q(o, t);
     return {
-      label: i,
+      label: o,
       insertText: s,
       kind: "operator",
       detail: n.detail,
       documentation: n.documentation,
-      sortOrder: 20 + o
+      sortOrder: 20 + a
     };
   });
 }
-function B(e, t) {
-  const a = [
+function q(e, t) {
+  const i = [
     "contains",
     "not_contains",
     "startswith",
@@ -485,18 +566,18 @@ function B(e, t) {
     "not_regexp",
     "matches",
     "not_matches"
-  ], i = ["exists", "not_exists"], o = ["is", "is_not"];
+  ], o = ["exists", "not_exists"], a = ["is", "is_not"];
   if (e === "in" || e === "not_in")
-    return _(t) ? `${e} [$1]` : `${e} ["$1"]`;
+    return T(t) ? `${e} [$1]` : `${e} ["$1"]`;
   if (e === "between" || e === "not_between")
-    return _(t) ? `${e} $1 AND $2` : `${e} "$1" AND "$2"`;
-  if (o.includes(e))
+    return T(t) ? `${e} $1 AND $2` : `${e} "$1" AND "$2"`;
+  if (a.includes(e))
     return `${e} null`;
-  if (i.includes(e))
+  if (o.includes(e))
     return e;
   if (e === "cidr" || e === "not_cidr")
     return `${e} "$1"`;
-  if (a.includes(e))
+  if (i.includes(e))
     return `${e} "$1"`;
   if (!t)
     return `${e} `;
@@ -523,11 +604,11 @@ function B(e, t) {
       return `${e} `;
   }
 }
-function _(e) {
+function T(e) {
   return e === "long" || e === "integer" || e === "double" || e === "float" || e === "short" || e === "byte" || e === "half_float" || e === "scaled_float" || e === "unsigned_long";
 }
-function T() {
-  return I.filter((e) => e !== "NOT").map(
+function _() {
+  return N.filter((e) => e !== "NOT").map(
     (e, t) => O(e, t)
   );
 }
@@ -540,17 +621,17 @@ function O(e, t = 0) {
     sortOrder: 30 + t
   };
 }
-function G(e, t) {
-  const a = [];
-  return e && t?.fieldValues?.[e] && t.fieldValues[e].forEach((o, n) => {
-    a.push({
-      label: o,
-      insertText: `"${o}"`,
+function j(e, t) {
+  const i = [];
+  return e && t?.fieldValues?.[e] && t.fieldValues[e].forEach((a, n) => {
+    i.push({
+      label: a,
+      insertText: `"${a}"`,
       kind: "value",
       detail: `Known value for ${e}`,
       sortOrder: 40 + n
     });
-  }), a.push(
+  }), i.push(
     {
       label: '"text"',
       insertText: '"$1"',
@@ -579,87 +660,135 @@ function G(e, t) {
       detail: "Null value",
       sortOrder: 53
     }
-  ), a;
+  ), i;
 }
-function V(e, t) {
-  return P.filter((i) => !t || i.label.toLowerCase().includes(t.toLowerCase())).map((i, o) => ({
-    label: i.label,
-    insertText: i.insertText,
+function B(e, t) {
+  return P.filter((o) => !t || o.label.toLowerCase().includes(t.toLowerCase())).map((o, a) => ({
+    label: o.label,
+    insertText: o.insertText,
     kind: "snippet",
-    detail: i.description,
-    documentation: `Insert: ${i.insertText}`,
-    sortOrder: 100 + o
+    detail: o.description,
+    documentation: `Insert: ${o.insertText}`,
+    sortOrder: 100 + a
   }));
 }
-function j(e) {
+function V(e) {
   return R.filter((t) => !e || t.toLowerCase().includes(e.toLowerCase())).map(
-    (t, a) => {
-      const i = M[t] || { detail: "Field mutator", documentation: "" };
+    (t, i) => {
+      const o = M[t] || { detail: "Field mutator", documentation: "" };
       return {
         label: t,
         insertText: t,
         kind: "mutator",
-        detail: i.detail,
-        documentation: i.documentation,
-        sortOrder: 60 + a
+        detail: o.detail,
+        documentation: o.documentation,
+        sortOrder: 60 + i
       };
     }
   );
 }
 function C(e) {
-  return S.filter(
+  return I.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, a) => ({
+  ).map((t, i) => ({
     label: t,
     insertText: `${t}($1)`,
     kind: "aggregation",
     detail: "Aggregation function",
-    sortOrder: 70 + a
+    sortOrder: 70 + i
   }));
 }
 function H(e) {
-  return L.filter(
+  return A.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, a) => ({
+  ).map((t, i) => ({
     label: t,
     insertText: t,
     kind: "typeHint",
     detail: "Type hint",
-    sortOrder: 80 + a
+    sortOrder: 80 + i
   }));
 }
 function Y(e) {
-  return A.filter(
+  return L.filter(
     (t) => !e || t.toLowerCase().includes(e.toLowerCase())
-  ).map((t, a) => ({
+  ).map((t, i) => ({
     label: t,
     insertText: t,
     kind: "visualization",
     detail: "Visualization type",
-    sortOrder: 90 + a
+    sortOrder: 90 + i
+  }));
+}
+const K = [
+  // Titles & labels
+  { name: "title", detail: "Chart title", insertText: 'title="' },
+  { name: "x_label", detail: "X-axis label", insertText: 'x_label="' },
+  { name: "y_label", detail: "Y-axis label", insertText: 'y_label="' },
+  { name: "labels", detail: "Show data labels: true, false, minmax", insertText: "labels=true" },
+  { name: "legend", detail: "Legend position: top, bottom, left, right", insertText: "legend=" },
+  // Chart modes
+  { name: "stacked", detail: "Stack data series (true/false)", insertText: "stacked=true" },
+  { name: "normalize", detail: "100% stacked mode (true/false)", insertText: "normalize=true" },
+  { name: "donut", detail: "Donut style for pie charts (true/false)", insertText: "donut=true" },
+  { name: "fill", detail: "Fill area under line (true/false)", insertText: "fill=true" },
+  { name: "smooth", detail: "Smooth line curves (true/false)", insertText: "smooth=true" },
+  // Data formatting
+  { name: "format", detail: "Number format: number, short, percent, bytes, duration", insertText: "format=" },
+  { name: "nulls", detail: "Null handling: zero, gaps, connect", insertText: "nulls=" },
+  { name: "sort", detail: "Sort order: desc, asc, none", insertText: "sort=desc" },
+  // Filtering
+  { name: "top", detail: "Show top N values (rest grouped as Other)", insertText: "top=" },
+  { name: "colors", detail: 'Colors: "key:#hex,...", "severity", "warm", "cool"', insertText: 'colors="' },
+  { name: "include", detail: 'Show only these values: "val1,val2,..."', insertText: 'include="' },
+  { name: "exclude", detail: 'Hide these values: "val1,val2,..."', insertText: 'exclude="' },
+  { name: "other", detail: "Group excluded values into Other bucket", insertText: "other=true" },
+  // Axis bounds
+  { name: "y_min", detail: "Y-axis minimum value", insertText: "y_min=" },
+  { name: "y_max", detail: "Y-axis maximum value", insertText: "y_max=" },
+  // Threshold / reference line
+  { name: "threshold", detail: "Horizontal threshold line value", insertText: "threshold=" },
+  { name: "threshold_color", detail: "Threshold line color (hex)", insertText: 'threshold_color="' },
+  { name: "threshold_label", detail: "Threshold line label text", insertText: 'threshold_label="' },
+  // Interaction
+  { name: "drilldown", detail: "Enable click-to-drill (true/false)", insertText: "drilldown=true" },
+  { name: "crosshair", detail: "Show all values at hover point (true/false)", insertText: "crosshair=true" },
+  { name: "link", detail: 'Template URL for value links: "https://...{{value}}"', insertText: 'link="' },
+  { name: "link_target", detail: "Link target: _self (default) or _blank", insertText: "link_target=" }
+];
+function W(e) {
+  return K.filter(
+    (t) => !e || t.name.toLowerCase().includes(e.toLowerCase())
+  ).map((t, i) => ({
+    label: t.name,
+    insertText: t.insertText,
+    kind: "visualization",
+    detail: t.detail,
+    sortOrder: 95 + i
   }));
 }
-function Q(e, t) {
-  const i = x(e).find(
-    (o) => o.start <= t && o.end >= t && o.type !== "whitespace"
+function ee(e, t) {
+  const o = x(e).find(
+    (a) => a.start <= t && a.end >= t && a.type !== "whitespace"
   );
-  return i ? {
-    word: i.value,
-    start: i.start,
-    end: i.end
+  return o ? {
+    word: o.value,
+    start: o.start,
+    end: o.end
   } : null;
 }
-function X() {
+function te() {
   return [" ", "(", ".", '"', "'", "|", ":", "="];
 }
-function ee(e, t, a) {
-  if (a === " " || a === "(" || a === "." || a === "|" || a === ":" || a === "=") return !0;
-  const i = x(e.substring(0, t)), o = i[i.length - 1];
-  return !!(o && o.type === "field" && o.value.length >= 2);
+function ae(e, t, i) {
+  if (!e) return !1;
+  if (i === " " || i === "(" || i === "." || i === "|" || i === ":" || i === "=") return !0;
+  const o = x(e.substring(0, t)), a = o[o.length - 1];
+  return !!(a && a.type === "field" && a.value.length >= 2);
 }
 export {
-  X as getCompletionTriggerCharacters,
-  J as getCompletions,
-  Q as getWordAtPosition,
-  ee as shouldTriggerCompletion
+  te as getCompletionTriggerCharacters,
+  Q as getCompletions,
+  ee as getWordAtPosition,
+  ae as shouldTriggerCompletion
 };