@tellaro/tql 0.1.0

package/dist/src/types.d.ts

@@ -0,0 +1,221 @@
+/**
+ * TQL (Tellaro Query Language) Type Definitions
+ *
+ * Comprehensive type system for TQL parsing, validation, and autocomplete.
+ * Synchronized with tellaro-query-language Python/Rust implementations.
+ */
+export type TqlTokenType = "field" | "operator" | "logicalOp" | "collectionOp" | "string" | "number" | "boolean" | "null" | "paren" | "bracket" | "comma" | "pipe" | "arrow" | "doubleColon" | "mutator" | "aggregation" | "keyword" | "typeHint" | "visualization" | "whitespace" | "unknown" | "error";
+export interface TqlToken {
+    type: TqlTokenType;
+    value: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    raw?: string;
+}
+export type TqlExpression = TqlBinaryExpression | TqlUnaryExpression | TqlComparisonExpression | TqlCollectionExpression | TqlMutatorExpression | TqlAggregationExpression | TqlStatsExpression | TqlGroupExpression | TqlLiteral | TqlFieldReference;
+export interface TqlBinaryExpression {
+    type: "binary";
+    operator: "AND" | "OR";
+    left: TqlExpression;
+    right: TqlExpression;
+    start: number;
+    end: number;
+}
+export interface TqlUnaryExpression {
+    type: "unary";
+    operator: "NOT";
+    operand: TqlExpression;
+    start: number;
+    end: number;
+}
+export interface TqlComparisonExpression {
+    type: "comparison";
+    field: TqlFieldReference | TqlMutatorExpression;
+    operator: TqlComparisonOperator;
+    value: TqlLiteral | TqlLiteral[];
+    start: number;
+    end: number;
+}
+export interface TqlCollectionExpression {
+    type: "collection";
+    operator: "ANY" | "ALL" | "NONE";
+    field: TqlFieldReference;
+    condition: TqlExpression;
+    start: number;
+    end: number;
+}
+export interface TqlMutatorExpression {
+    type: "mutator";
+    mutator: TqlMutator;
+    field: TqlFieldReference | TqlMutatorExpression;
+    args?: TqlLiteral[];
+    start: number;
+    end: number;
+}
+export interface TqlAggregationExpression {
+    type: "aggregation";
+    function: TqlAggregationFunction;
+    field?: TqlFieldReference;
+    args?: (string | number)[];
+    alias?: string;
+    start: number;
+    end: number;
+}
+export interface TqlStatsExpression {
+    type: "stats";
+    aggregations: TqlAggregationExpression[];
+    groupBy?: TqlFieldReference[];
+    topN?: number;
+    bottomN?: number;
+    visualization?: TqlVisualizationType;
+    start: number;
+    end: number;
+}
+export interface TqlGroupExpression {
+    type: "group";
+    expression: TqlExpression;
+    start: number;
+    end: number;
+}
+export interface TqlLiteral {
+    type: "literal";
+    valueType: "string" | "number" | "boolean" | "null";
+    value: string | number | boolean | null;
+    start: number;
+    end: number;
+}
+export interface TqlFieldReference {
+    type: "field";
+    name: string;
+    path: string[];
+    mutators?: string[];
+    typeHint?: TqlTypeHint;
+    start: number;
+    end: number;
+}
+export type TqlComparisonOperator = "eq" | "ne" | "=" | "!=" | "==" | "gt" | "gte" | "lt" | "lte" | ">" | ">=" | "<" | "<=" | "contains" | "not_contains" | "!contains" | "startswith" | "not_startswith" | "!startswith" | "endswith" | "not_endswith" | "!endswith" | "regexp" | "regex" | "not_regexp" | "!regexp" | "matches" | "not_matches" | "!matches" | "between" | "not_between" | "!between" | "in" | "not_in" | "!in" | "exists" | "not_exists" | "!exists" | "is" | "is_not" | "!is" | "cidr" | "not_cidr" | "!cidr" | "any" | "all" | "none" | "not_any" | "not_all" | "not_none" | "!any" | "!all" | "!none";
+export type TqlLogicalOperator = "AND" | "OR" | "NOT";
+export type TqlCollectionOperator = "ANY" | "ALL" | "NONE";
+export type TqlMutator = "lowercase" | "uppercase" | "trim" | "split" | "length" | "replace" | "b64encode" | "b64decode" | "urldecode" | "hexencode" | "hexdecode" | "md5" | "sha256" | "refang" | "defang" | "is_private" | "is_global" | "nslookup" | "geoip_lookup" | "geoip" | "geo" | "any" | "all" | "avg" | "average" | "sum" | "min" | "max";
+export type TqlAggregationFunction = "count" | "sum" | "avg" | "average" | "mean" | "median" | "med" | "min" | "max" | "percentile" | "percentiles" | "p" | "pct" | "percentile_rank" | "percentile_ranks" | "pct_rank" | "pct_ranks" | "std" | "standard_deviation" | "unique_count" | "cardinality" | "values" | "unique" | "distinct";
+export type TqlTypeHint = "string" | "str" | "number" | "int" | "integer" | "float" | "double" | "decimal" | "date" | "bool" | "boolean" | "array" | "list" | "object" | "geo";
+export type TqlVisualizationType = "bar" | "barchart" | "line" | "area" | "pie" | "donut" | "scatter" | "heatmap" | "treemap" | "sunburst" | "table" | "number" | "gauge" | "map" | "grouped_bar" | "stacked_bar" | "nested_pie" | "nested_donut" | "chord";
+export interface TqlParseResult {
+    ast: TqlExpression | null;
+    tokens: TqlToken[];
+    errors: TqlParseError[];
+    warnings: TqlParseWarning[];
+    success: boolean;
+}
+export interface TqlParseError {
+    message: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    severity: "error";
+    code: TqlErrorCode;
+    suggestion?: string;
+}
+export interface TqlParseWarning {
+    message: string;
+    start: number;
+    end: number;
+    line: number;
+    column: number;
+    severity: "warning";
+    code: TqlWarningCode;
+    suggestion?: string;
+}
+export type TqlErrorCode = "UNEXPECTED_TOKEN" | "UNEXPECTED_END" | "UNBALANCED_PARENS" | "UNBALANCED_BRACKETS" | "UNTERMINATED_STRING" | "INVALID_OPERATOR" | "INVALID_MUTATOR" | "INVALID_VALUE" | "MISSING_OPERAND" | "MISSING_OPERATOR" | "MISSING_VALUE" | "MISSING_FIELD" | "MISSING_MUTATOR" | "INVALID_SYNTAX" | "MAX_DEPTH_EXCEEDED" | "TYPE_MISMATCH";
+export type TqlWarningCode = "UNKNOWN_FIELD" | "TYPE_MISMATCH" | "DEPRECATED_OPERATOR" | "REDUNDANT_PARENS";
+export interface TqlValidationResult {
+    valid: boolean;
+    errors: TqlParseError[];
+    warnings: TqlParseWarning[];
+}
+export interface TqlValidationOptions {
+    availableFields?: string[];
+    fieldTypes?: Record<string, TqlFieldType>;
+    strictMode?: boolean;
+    allowAggregations?: boolean;
+    allowMutators?: boolean;
+    maxDepth?: number;
+}
+export type TqlFieldType = "text" | "keyword" | "long" | "integer" | "short" | "byte" | "double" | "float" | "half_float" | "scaled_float" | "unsigned_long" | "date" | "boolean" | "ip" | "nested" | "object" | "geo_point";
+export interface TqlCompletionItem {
+    label: string;
+    insertText: string;
+    kind: TqlCompletionKind;
+    detail?: string;
+    documentation?: string;
+    sortOrder: number;
+    filterText?: string;
+    commitCharacters?: string[];
+}
+export type TqlCompletionKind = "field" | "operator" | "value" | "keyword" | "snippet" | "mutator" | "aggregation" | "logicalOp" | "typeHint" | "visualization";
+export interface TqlCompletionContext {
+    query: string;
+    cursorPosition: number;
+    triggerKind: "invoked" | "character" | "automatic";
+    triggerCharacter?: string;
+}
+export interface TqlCompletionOptions {
+    fields?: TqlFieldSchema[];
+    includeSnippets?: boolean;
+    includeMutators?: boolean;
+    includeAggregations?: boolean;
+    includeTypeHints?: boolean;
+    includeVisualizations?: boolean;
+    maxItems?: number;
+    fieldValues?: Record<string, string[]>;
+}
+export interface TqlFieldSchema {
+    name: string;
+    type: TqlFieldType;
+    description?: string;
+    examples?: string[];
+    path?: string[];
+    nested?: TqlFieldSchema[];
+}
+export interface TqlSnippet {
+    label: string;
+    insertText: string;
+    description?: string;
+    category?: string;
+}
+export interface TqlInputProps {
+    modelValue: string;
+    placeholder?: string;
+    disabled?: boolean;
+    readonly?: boolean;
+    rows?: number;
+    multiline?: boolean;
+    showValidation?: boolean;
+    validateOnInput?: boolean;
+    debounceMs?: number;
+    fieldSchema?: TqlFieldSchema[];
+    modelName?: string;
+    snippets?: TqlSnippet[];
+    showSnippetButton?: boolean;
+    autocomplete?: boolean;
+    syntaxHighlighting?: boolean;
+}
+export interface TqlInputEmits {
+    (e: "update:modelValue", value: string): void;
+    (e: "validation", result: TqlValidationResult): void;
+    (e: "parse", result: TqlParseResult): void;
+    (e: "submit", value: string): void;
+}
+export interface TqlInputExpose {
+    focus(): void;
+    blur(): void;
+    validate(): TqlValidationResult;
+    insertText(text: string): void;
+    insertSnippet(snippet: TqlSnippet): void;
+    getTokenAtPosition(pos: number): TqlToken | null;
+    getCursorPosition(): number;
+    setCursorPosition(pos: number): void;
+}

package/dist/src/validator.d.ts

@@ -0,0 +1,46 @@
+import { TqlParseError, TqlParseWarning, TqlValidationOptions, TqlValidationResult } from './types';
+
+export declare class TqlValidator {
+    private options;
+    private errors;
+    private warnings;
+    constructor(options?: TqlValidationOptions);
+    /**
+     * Validate a TQL query
+     */
+    validate(query: string): TqlValidationResult;
+    /**
+     * Validate an expression recursively
+     */
+    private validateExpression;
+    /**
+     * Validate a comparison expression
+     */
+    private validateComparison;
+    /**
+     * Suggest a similar field name using Levenshtein distance
+     */
+    private suggestField;
+    /**
+     * Calculate Levenshtein distance between two strings
+     */
+    private levenshteinDistance;
+    private addError;
+    private addWarning;
+}
+/**
+ * Validate a TQL query with options
+ */
+export declare function validateTql(query: string, options?: TqlValidationOptions): TqlValidationResult;
+/**
+ * Quick check if TQL is valid (syntax only)
+ */
+export declare function isValidTqlSyntax(query: string): boolean;
+/**
+ * Get all validation issues (errors + warnings)
+ */
+export declare function getTqlIssues(query: string, options?: TqlValidationOptions): (TqlParseError | TqlParseWarning)[];
+/**
+ * Format validation result for display
+ */
+export declare function formatValidationResult(result: TqlValidationResult): string;

package/dist/src/validator.js

@@ -0,0 +1,315 @@
+var b = Object.defineProperty;
+var u = (s, e, t) => e in s ? b(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var r = (s, e, t) => u(s, typeof e != "symbol" ? e + "" : e, t);
+import { parseTql as c } from "./parser.js";
+const f = {
+  // Equality (all types)
+  eq: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  ne: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  "=": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  "==": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  "!=": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  // Comparison (numeric and dates)
+  gt: ["long", "integer", "double", "float", "date"],
+  gte: ["long", "integer", "double", "float", "date"],
+  lt: ["long", "integer", "double", "float", "date"],
+  lte: ["long", "integer", "double", "float", "date"],
+  ">": ["long", "integer", "double", "float", "date"],
+  ">=": ["long", "integer", "double", "float", "date"],
+  "<": ["long", "integer", "double", "float", "date"],
+  "<=": ["long", "integer", "double", "float", "date"],
+  // String operations
+  contains: ["text", "keyword"],
+  not_contains: ["text", "keyword"],
+  "!contains": ["text", "keyword"],
+  startswith: ["text", "keyword"],
+  not_startswith: ["text", "keyword"],
+  "!startswith": ["text", "keyword"],
+  endswith: ["text", "keyword"],
+  not_endswith: ["text", "keyword"],
+  "!endswith": ["text", "keyword"],
+  regexp: ["text", "keyword"],
+  regex: ["text", "keyword"],
+  not_regexp: ["text", "keyword"],
+  "!regexp": ["text", "keyword"],
+  matches: ["text", "keyword"],
+  not_matches: ["text", "keyword"],
+  "!matches": ["text", "keyword"],
+  // Range
+  between: ["long", "integer", "double", "float", "date"],
+  not_between: ["long", "integer", "double", "float", "date"],
+  "!between": ["long", "integer", "double", "float", "date"],
+  in: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
+  not_in: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
+  "!in": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip"],
+  // Existence (all types)
+  exists: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  not_exists: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  "!exists": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  // Null checks (all types)
+  is: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  is_not: ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  "!is": ["text", "keyword", "long", "integer", "double", "float", "date", "boolean", "ip", "nested", "object", "geo_point"],
+  // IP-specific operators
+  cidr: ["ip"],
+  not_cidr: ["ip"],
+  "!cidr": ["ip"],
+  // Collection operators
+  any: ["nested", "object", "keyword", "text"],
+  all: ["nested", "object", "keyword", "text"],
+  none: ["nested", "object", "keyword", "text"],
+  not_any: ["nested", "object", "keyword", "text"],
+  not_all: ["nested", "object", "keyword", "text"],
+  not_none: ["nested", "object", "keyword", "text"],
+  "!any": ["nested", "object", "keyword", "text"],
+  "!all": ["nested", "object", "keyword", "text"],
+  "!none": ["nested", "object", "keyword", "text"]
+}, d = {
+  cidr: ["ip"],
+  not_cidr: ["ip"],
+  "!cidr": ["ip"]
+}, h = {
+  eq: ["string", "number", "boolean"],
+  ne: ["string", "number", "boolean"],
+  "=": ["string", "number", "boolean"],
+  "==": ["string", "number", "boolean"],
+  "!=": ["string", "number", "boolean"],
+  gt: ["number", "string"],
+  gte: ["number", "string"],
+  lt: ["number", "string"],
+  lte: ["number", "string"],
+  ">": ["number", "string"],
+  ">=": ["number", "string"],
+  "<": ["number", "string"],
+  "<=": ["number", "string"],
+  contains: ["string"],
+  not_contains: ["string"],
+  "!contains": ["string"],
+  startswith: ["string"],
+  not_startswith: ["string"],
+  "!startswith": ["string"],
+  endswith: ["string"],
+  not_endswith: ["string"],
+  "!endswith": ["string"],
+  regexp: ["string"],
+  regex: ["string"],
+  not_regexp: ["string"],
+  "!regexp": ["string"],
+  matches: ["string"],
+  not_matches: ["string"],
+  "!matches": ["string"],
+  between: ["number", "string"],
+  not_between: ["number", "string"],
+  "!between": ["number", "string"],
+  in: ["string", "number", "boolean"],
+  not_in: ["string", "number", "boolean"],
+  "!in": ["string", "number", "boolean"],
+  exists: ["boolean"],
+  not_exists: ["boolean"],
+  "!exists": ["boolean"],
+  is: ["null"],
+  is_not: ["null"],
+  "!is": ["null"],
+  cidr: ["string"],
+  not_cidr: ["string"],
+  "!cidr": ["string"],
+  any: ["string", "number", "boolean"],
+  all: ["string", "number", "boolean"],
+  none: ["string", "number", "boolean"],
+  not_any: ["string", "number", "boolean"],
+  not_all: ["string", "number", "boolean"],
+  not_none: ["string", "number", "boolean"],
+  "!any": ["string", "number", "boolean"],
+  "!all": ["string", "number", "boolean"],
+  "!none": ["string", "number", "boolean"]
+};
+class y {
+  constructor(e = {}) {
+    r(this, "options");
+    r(this, "errors");
+    r(this, "warnings");
+    this.options = e, this.errors = [], this.warnings = [];
+  }
+  /**
+   * Validate a TQL query
+   */
+  validate(e) {
+    this.errors = [], this.warnings = [];
+    const t = c(e);
+    return this.errors.push(...t.errors), this.warnings.push(...t.warnings), t.ast && this.validateExpression(t.ast), {
+      valid: this.errors.length === 0,
+      errors: this.errors,
+      warnings: this.warnings
+    };
+  }
+  /**
+   * Validate an expression recursively
+   */
+  validateExpression(e) {
+    switch (e.type) {
+      case "binary":
+        this.validateExpression(e.left), this.validateExpression(e.right);
+        break;
+      case "unary":
+        this.validateExpression(e.operand);
+        break;
+      case "group":
+        this.validateExpression(e.expression);
+        break;
+      case "comparison":
+        this.validateComparison(e);
+        break;
+    }
+  }
+  /**
+   * Validate a comparison expression
+   */
+  validateComparison(e) {
+    const t = e.field.type === "field" ? e.field.name : "computed";
+    if (this.options.availableFields && this.options.strictMode && !this.options.availableFields.includes(t) && e.field.type === "field" && this.addWarning(
+      `Unknown field '${t}'`,
+      e.field.start,
+      e.field.end,
+      (e.field.type === "field", 1),
+      1,
+      "UNKNOWN_FIELD",
+      `Did you mean: ${this.suggestField(t)}`
+    ), this.options.fieldTypes && e.field.type === "field") {
+      const o = this.options.fieldTypes[t];
+      if (o) {
+        const n = d[e.operator];
+        n && !n.includes(o) && this.addError(
+          `Operator '${e.operator}' requires field type ${n.join(" or ")}, but '${t}' is type '${o}'`,
+          e.start,
+          e.end,
+          1,
+          1,
+          "TYPE_MISMATCH",
+          `Use '${e.operator}' only with ${n.join(" or ")} fields`
+        );
+      }
+    }
+    if (this.options.fieldTypes && e.field.type === "field") {
+      const o = this.options.fieldTypes[t];
+      if (o) {
+        const n = f[e.operator];
+        !d[e.operator] && n && !n.includes(o) && this.addWarning(
+          `Operator '${e.operator}' may not work well with field type '${o}'`,
+          e.start,
+          e.end,
+          1,
+          1,
+          "TYPE_MISMATCH",
+          `Consider using a different operator for ${o} fields`
+        );
+      }
+    }
+    if (!Array.isArray(e.value) && e.value.type === "literal") {
+      const o = h[e.operator];
+      o && !o.includes(e.value.valueType) && this.addWarning(
+        `Operator '${e.operator}' expects ${o.join(" or ")} value`,
+        e.value.start,
+        e.value.end,
+        1,
+        1,
+        "TYPE_MISMATCH"
+      );
+    }
+    if ((e.operator === "regexp" || e.operator === "regex" || e.operator === "not_regexp" || e.operator === "matches" || e.operator === "not_matches") && !Array.isArray(e.value) && e.value.valueType === "string" && typeof e.value.value == "string")
+      try {
+        new RegExp(e.value.value);
+      } catch {
+        this.addError(
+          `Invalid regular expression: ${e.value.value}`,
+          e.value.start,
+          e.value.end,
+          1,
+          1,
+          "INVALID_VALUE",
+          "Check the regex syntax"
+        );
+      }
+  }
+  /**
+   * Suggest a similar field name using Levenshtein distance
+   */
+  suggestField(e) {
+    if (!this.options.availableFields || this.options.availableFields.length === 0)
+      return "check available fields";
+    let t = this.options.availableFields[0], o = this.levenshteinDistance(e, t);
+    for (const n of this.options.availableFields) {
+      const i = this.levenshteinDistance(e, n);
+      i < o && (o = i, t = n);
+    }
+    return t;
+  }
+  /**
+   * Calculate Levenshtein distance between two strings
+   */
+  levenshteinDistance(e, t) {
+    const o = [];
+    for (let n = 0; n <= t.length; n++)
+      o[n] = [n];
+    for (let n = 0; n <= e.length; n++)
+      o[0][n] = n;
+    for (let n = 1; n <= t.length; n++)
+      for (let i = 1; i <= e.length; i++)
+        t.charAt(n - 1) === e.charAt(i - 1) ? o[n][i] = o[n - 1][i - 1] : o[n][i] = Math.min(
+          o[n - 1][i - 1] + 1,
+          o[n][i - 1] + 1,
+          o[n - 1][i] + 1
+        );
+    return o[t.length][e.length];
+  }
+  addError(e, t, o, n, i, a, l) {
+    this.errors.push({
+      message: e,
+      start: t,
+      end: o,
+      line: n,
+      column: i,
+      severity: "error",
+      code: a,
+      suggestion: l
+    });
+  }
+  addWarning(e, t, o, n, i, a, l) {
+    this.warnings.push({
+      message: e,
+      start: t,
+      end: o,
+      line: n,
+      column: i,
+      severity: "warning",
+      code: a,
+      suggestion: l
+    });
+  }
+}
+function g(s, e) {
+  return new y(e).validate(s);
+}
+function _(s) {
+  return g(s).valid;
+}
+function m(s, e) {
+  const t = g(s, e);
+  return [...t.errors, ...t.warnings];
+}
+function v(s) {
+  const e = [];
+  s.valid ? e.push("Query is valid") : e.push("Query has errors:");
+  for (const t of s.errors)
+    e.push(`  Error: ${t.message}`), t.suggestion && e.push(`    Suggestion: ${t.suggestion}`);
+  for (const t of s.warnings)
+    e.push(`  Warning: ${t.message}`), t.suggestion && e.push(`    Suggestion: ${t.suggestion}`);
+  return e.join(`
+`);
+}
+export {
+  y as TqlValidator,
+  v as formatValidationResult,
+  m as getTqlIssues,
+  _ as isValidTqlSyntax,
+  g as validateTql
+};

package/dist/style.css

@@ -0,0 +1 @@
+.tql-autocomplete-dropdown[data-v-6381bbdd]{position:fixed;top:var(--dropdown-top);left:var(--dropdown-left);z-index:9999;min-width:280px;max-width:450px;max-height:var(--dropdown-max-height);background:var(--surface-overlay, #fff);border:1px solid var(--surface-border, #ddd);border-radius:var(--border-radius, 6px);box-shadow:0 4px 16px #00000026;overflow:hidden;display:flex;flex-direction:column}.tql-completion-list[data-v-6381bbdd]{overflow-y:auto;max-height:calc(var(--dropdown-max-height) - 60px)}.tql-completion-item[data-v-6381bbdd]{display:flex;align-items:center;gap:.5rem;padding:.5rem .75rem;cursor:pointer;transition:background-color .15s}.tql-completion-item[data-v-6381bbdd]:hover,.tql-completion-item.selected[data-v-6381bbdd]{background:var(--highlight-bg, #f0f0f0)}.tql-completion-icon[data-v-6381bbdd]{display:flex;align-items:center;justify-content:center;width:1.5rem;height:1.5rem;border-radius:4px;font-size:.75rem}.tql-completion-icon.tql-completion-kind-field[data-v-6381bbdd]{background:var(--blue-100, #e3f2fd);color:var(--blue-600, #1e88e5)}.tql-completion-icon.tql-completion-kind-operator[data-v-6381bbdd]{background:var(--pink-100, #fce4ec);color:var(--pink-600, #d81b60)}.tql-completion-icon.tql-completion-kind-value[data-v-6381bbdd]{background:var(--green-100, #e8f5e9);color:var(--green-600, #43a047)}.tql-completion-icon.tql-completion-kind-keyword[data-v-6381bbdd]{background:var(--purple-100, #f3e5f5);color:var(--purple-600, #8e24aa)}.tql-completion-icon.tql-completion-kind-snippet[data-v-6381bbdd]{background:var(--orange-100, #fff3e0);color:var(--orange-600, #fb8c00)}.tql-completion-icon.tql-completion-kind-mutator[data-v-6381bbdd]{background:var(--cyan-100, #e0f7fa);color:var(--cyan-600, #00acc1)}.tql-completion-icon.tql-completion-kind-aggregation[data-v-6381bbdd]{background:var(--indigo-100, #e8eaf6);color:var(--indigo-600, #3949ab)}.tql-completion-icon.tql-completion-kind-logicalOp[data-v-6381bbdd]{background:var(--yellow-100, #fffde7);color:var(--yellow-700, #fbc02d)}.tql-completion-icon.tql-completion-kind-typeHint[data-v-6381bbdd]{background:var(--teal-100, #e0f2f1);color:var(--teal-600, #00897b)}.tql-completion-icon.tql-completion-kind-visualization[data-v-6381bbdd]{background:var(--red-100, #ffebee);color:var(--red-600, #e53935)}.tql-completion-content[data-v-6381bbdd]{flex:1;display:flex;flex-direction:column;min-width:0}.tql-completion-label[data-v-6381bbdd]{font-family:Courier New,monospace;font-size:.875rem;font-weight:500;color:var(--text-color, #333);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.tql-completion-detail[data-v-6381bbdd]{font-size:.75rem;color:var(--text-color-secondary, #666);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.tql-completion-kind-badge[data-v-6381bbdd]{font-size:.625rem;padding:.125rem .375rem;background:var(--surface-100, #f5f5f5);border-radius:3px;color:var(--text-color-secondary, #666);text-transform:uppercase;letter-spacing:.025em}.tql-completion-docs[data-v-6381bbdd]{padding:.5rem .75rem;border-top:1px solid var(--surface-border, #ddd);background:var(--surface-50, #fafafa);font-size:.75rem;color:var(--text-color-secondary, #666);max-height:60px;overflow-y:auto}.tql-input-wrapper[data-v-c0e226bb]{position:relative;display:flex;align-items:flex-start;border:1px solid var(--surface-border, #ddd);border-radius:var(--border-radius, 6px);background:var(--surface-ground, #fff);transition:border-color .2s,box-shadow .2s}.tql-input-wrapper.tql-input-focused[data-v-c0e226bb]{border-color:var(--primary-color, #3b82f6);box-shadow:0 0 0 2px var(--primary-100, rgba(59, 130, 246, .2))}.tql-input-wrapper.tql-input-invalid[data-v-c0e226bb]{border-color:var(--red-500, #ef4444)}.tql-input-wrapper.tql-input-invalid.tql-input-focused[data-v-c0e226bb]{box-shadow:0 0 0 2px var(--red-100, rgba(239, 68, 68, .2))}.tql-input-wrapper.tql-input-disabled[data-v-c0e226bb]{opacity:.6;cursor:not-allowed}.tql-highlight-layer[data-v-c0e226bb]{position:absolute;top:0;left:0;right:0;bottom:0;padding:.5rem .75rem;pointer-events:none;white-space:pre-wrap;word-wrap:break-word;font-family:Courier New,monospace;font-size:.875rem;line-height:1.5;overflow:hidden}.tql-input-multiline .tql-highlight-layer[data-v-c0e226bb]{overflow-y:auto}.tql-input[data-v-c0e226bb]{flex:1;width:100%;padding:.5rem 2.5rem .5rem .75rem;border:none;background:transparent;font-family:Courier New,monospace;font-size:.875rem;line-height:1.5;color:var(--text-color, #333);outline:none;resize:none}.tql-input.tql-input-highlighted[data-v-c0e226bb]{color:transparent;caret-color:var(--text-color, #333)}.tql-input[data-v-c0e226bb]::placeholder{color:var(--text-color-secondary, #666);opacity:.7}.tql-input[data-v-c0e226bb]:disabled{cursor:not-allowed}.tql-token-field[data-v-c0e226bb]{color:var(--tql-field-color, var(--blue-600, #2563eb))}.tql-token-operator[data-v-c0e226bb]{color:var(--tql-operator-color, var(--pink-600, #db2777));font-weight:500}.tql-token-logicalOp[data-v-c0e226bb]{color:var(--tql-logical-color, var(--purple-600, #9333ea));font-weight:600}.tql-token-collectionOp[data-v-c0e226bb]{color:var(--tql-collection-color, var(--indigo-600, #4f46e5));font-weight:600}.tql-token-string[data-v-c0e226bb]{color:var(--tql-string-color, var(--green-600, #16a34a))}.tql-token-number[data-v-c0e226bb]{color:var(--tql-number-color, var(--orange-600, #ea580c))}.tql-token-boolean[data-v-c0e226bb]{color:var(--tql-boolean-color, var(--cyan-600, #0891b2))}.tql-token-null[data-v-c0e226bb]{color:var(--tql-null-color, var(--gray-500, #6b7280));font-style:italic}.tql-token-mutator[data-v-c0e226bb]{color:var(--tql-mutator-color, var(--teal-600, #0d9488));font-style:italic}.tql-token-aggregation[data-v-c0e226bb]{color:var(--tql-aggregation-color, var(--indigo-600, #4f46e5))}.tql-token-keyword[data-v-c0e226bb]{color:var(--tql-keyword-color, var(--purple-500, #a855f7))}.tql-token-typeHint[data-v-c0e226bb]{color:var(--tql-typehint-color, var(--teal-500, #14b8a6))}.tql-token-visualization[data-v-c0e226bb]{color:var(--tql-viz-color, var(--red-500, #ef4444))}.tql-token-arrow[data-v-c0e226bb]{color:var(--tql-arrow-color, var(--gray-600, #4b5563));font-weight:600}.tql-token-doubleColon[data-v-c0e226bb]{color:var(--tql-colon-color, var(--gray-500, #6b7280))}.tql-token-paren[data-v-c0e226bb],.tql-token-bracket[data-v-c0e226bb]{color:var(--tql-bracket-color, var(--gray-600, #4b5563))}.tql-token-error[data-v-c0e226bb]{color:var(--tql-error-color, var(--red-600, #dc2626));text-decoration:wavy underline;text-decoration-color:var(--red-400, #f87171)}.tql-token-error-range[data-v-c0e226bb]{background-color:var(--red-50, #fef2f2)}.tql-token-unknown[data-v-c0e226bb]{color:var(--text-color-secondary, #666)}.tql-validation-icon[data-v-c0e226bb]{position:absolute;right:.5rem;top:50%;transform:translateY(-50%);display:flex;align-items:center;justify-content:center}.tql-input-multiline .tql-validation-icon[data-v-c0e226bb]{top:.75rem;transform:none}.tql-icon-valid[data-v-c0e226bb]{color:var(--green-500, #22c55e)}.tql-icon-invalid[data-v-c0e226bb]{color:var(--red-500, #ef4444)}.tql-icon-clickable[data-v-c0e226bb]{cursor:pointer;transition:transform .2s}.tql-icon-clickable[data-v-c0e226bb]:hover{transform:scale(1.2)}.tql-icon-clickable[data-v-c0e226bb]:focus{outline:2px solid var(--primary-color, #3b82f6);outline-offset:2px;border-radius:50%}.tql-snippet-button[data-v-c0e226bb]{position:absolute;right:2rem;top:50%;transform:translateY(-50%);padding:.25rem;border:none;background:transparent;color:var(--text-color-secondary, #666);cursor:pointer;border-radius:var(--border-radius, 6px);transition:color .2s,background-color .2s}.tql-snippet-button[data-v-c0e226bb]:hover{color:var(--primary-color, #3b82f6);background:var(--surface-100, #f5f5f5)}.tql-input-multiline .tql-snippet-button[data-v-c0e226bb]{top:.75rem;transform:none}.tql-validation-messages[data-v-c0e226bb]{position:absolute;top:100%;left:0;right:0;margin-top:.25rem;background:var(--surface-overlay, #fff);border:1px solid var(--red-200, #fecaca);border-radius:var(--border-radius, 6px);padding:.5rem;z-index:10;box-shadow:0 2px 8px #0000001a}.tql-error-message[data-v-c0e226bb]{display:flex;align-items:flex-start;gap:.5rem;padding:.25rem 0;font-size:.75rem;color:var(--red-600, #dc2626)}.tql-error-message i[data-v-c0e226bb]{margin-top:.125rem;font-size:.75rem}.tql-error-suggestion[data-v-c0e226bb]{display:block;color:var(--text-color-secondary, #666);font-style:italic;margin-left:1.25rem}

package/dist/vue/TqlAutocomplete.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/vue/TqlAutocomplete.vue.js

@@ -0,0 +1,7 @@
+import o from "./TqlAutocomplete.vue2.js";
+/* empty css                     */
+import t from "../_virtual/_plugin-vue_export-helper.js";
+const e = /* @__PURE__ */ t(o, [["__scopeId", "data-v-6381bbdd"]]);
+export {
+  e as default
+};