@tellaro/tql 0.1.0 → 0.1.2

package/dist/vue/components/TqlPreview.vue.d.ts

@@ -0,0 +1,4 @@
+declare const TqlPreviewNode: any;
+export { TqlPreviewNode };
+declare const _default: any;
+export default _default;

package/dist/vue/components/TqlPreview.vue.js

@@ -0,0 +1,9 @@
+import e from "./TqlPreview.vue2.js";
+import { TqlPreviewNode as i } from "./TqlPreview.vue2.js";
+/* empty css                */
+import o from "../../_virtual/_plugin-vue_export-helper.js";
+const p = /* @__PURE__ */ o(e, [["__scopeId", "data-v-bae811e6"]]);
+export {
+  i as TqlPreviewNode,
+  p as default
+};

package/dist/vue/components/TqlPreview.vue2.js

@@ -0,0 +1,264 @@
+import { defineComponent as $, computed as v, ref as D, openBlock as i, createElementBlock as o, normalizeClass as f, createElementVNode as s, Fragment as h, toDisplayString as a, createCommentVNode as u, renderList as q, createVNode as P, unref as j } from "vue";
+import { generatePreview as A } from "../../src/semanticPreview.js";
+const F = {
+  key: 0,
+  class: "tql-preview__empty"
+}, O = {
+  key: 0,
+  class: "tql-preview__complexity"
+}, V = { class: "tql-preview__field-count" }, K = {
+  key: 1,
+  class: "tql-preview__warnings"
+}, U = { class: "tql-preview__warning-icon" }, I = { class: "tql-preview__warning-text" }, M = {
+  key: 2,
+  class: "tql-preview__suggestions"
+}, z = { class: "tql-preview__suggestions-list" }, H = {
+  key: 3,
+  class: "tql-preview__tree"
+}, Q = { class: "tql-preview__tree-content" }, G = {
+  key: 4,
+  class: "tql-preview__fields"
+}, J = { class: "tql-preview__fields-list" }, R = ["onClick"], W = { class: "tql-preview__field-name" }, X = {
+  key: 0,
+  class: "tql-preview__field-mutators"
+}, Y = { class: "tql-preview__field-operator" }, Z = { class: "tql-preview__field-value" }, ee = ["title"], te = {
+  key: 5,
+  class: "tql-preview__operators"
+}, ne = { class: "tql-preview__operators-list" }, le = $({
+  name: "TqlPreviewNode",
+  props: {
+    node: {
+      type: Object,
+      required: !0
+    },
+    depth: {
+      type: Number,
+      default: 0
+    },
+    nodeKey: {
+      type: String,
+      required: !0
+    },
+    isExpanded: {
+      type: Boolean,
+      default: !0
+    },
+    autoExpandDepth: {
+      type: Number,
+      default: 3
+    }
+  },
+  emits: ["toggle", "node-click"],
+  setup(t, { emit: m }) {
+    const _ = v(() => t.node.children && t.node.children.length > 0), y = v(() => {
+      var r;
+      if (t.node.type === "comparison") {
+        const k = (r = t.node.mutators) != null && r.length ? ` | ${t.node.mutators.join(" | ")}` : "", C = n(t.node.value);
+        return `${t.node.field}${k} ${t.node.operator} ${C}`;
+      }
+      return t.node.type;
+    });
+    function n(r) {
+      return r === null ? "null" : r === void 0 ? "" : typeof r == "string" ? `"${r}"` : Array.isArray(r) ? `[${r.map(n).join(", ")}]` : String(r);
+    }
+    function g() {
+      m("toggle", t.nodeKey);
+    }
+    function w() {
+      m("node-click", t.node);
+    }
+    function x(r) {
+      return `${t.nodeKey}-${r}`;
+    }
+    function p(r) {
+      return t.depth + 1 < t.autoExpandDepth;
+    }
+    return {
+      hasChildren: _,
+      nodeLabel: y,
+      handleToggle: g,
+      handleClick: w,
+      getChildKey: x,
+      shouldChildExpand: p
+    };
+  },
+  template: `
+    <div class="tql-preview__node" :class="'tql-preview__node--' + node.type.toLowerCase()">
+      <div
+        class="tql-preview__node-content"
+        :style="{ paddingLeft: depth * 16 + 'px' }"
+        @click="handleClick"
+      >
+        <button
+          v-if="hasChildren"
+          class="tql-preview__node-toggle"
+          @click.stop="handleToggle"
+        >
+          {{ isExpanded ? '-' : '+' }}
+        </button>
+        <span v-else class="tql-preview__node-toggle tql-preview__node-toggle--leaf">
+          -
+        </span>
+        <span class="tql-preview__node-type" v-if="node.type !== 'comparison'">
+          {{ node.type }}
+        </span>
+        <span class="tql-preview__node-label">{{ nodeLabel }}</span>
+      </div>
+      <div v-if="hasChildren && isExpanded" class="tql-preview__node-children">
+        <TqlPreviewNode
+          v-for="(child, index) in node.children"
+          :key="getChildKey(index)"
+          :node="child"
+          :depth="depth + 1"
+          :node-key="getChildKey(index)"
+          :is-expanded="shouldChildExpand(index)"
+          :auto-expand-depth="autoExpandDepth"
+          @toggle="(key) => $emit('toggle', key)"
+          @node-click="(n) => $emit('node-click', n)"
+        />
+      </div>
+    </div>
+  `
+}), re = /* @__PURE__ */ $({
+  __name: "TqlPreview",
+  props: {
+    query: {},
+    showLogicTree: { type: Boolean, default: !0 },
+    showFieldUsage: { type: Boolean, default: !0 },
+    showComplexity: { type: Boolean, default: !0 },
+    showOperatorSummary: { type: Boolean, default: !1 },
+    maxExpandedDepth: { default: 3 },
+    compact: { type: Boolean, default: !1 }
+  },
+  emits: ["field-click", "node-click"],
+  setup(t, { emit: m }) {
+    const _ = t, y = m, n = v(() => A(_.query)), g = v(() => !_.query.trim() || !n.value.logicTree), w = v(() => {
+      const e = n.value.complexity.score;
+      return {
+        "tql-preview--low": e === "low",
+        "tql-preview--medium": e === "medium",
+        "tql-preview--high": e === "high"
+      };
+    }), x = v(() => ({
+      low: "Low complexity",
+      medium: "Medium complexity",
+      high: "High complexity"
+    })[n.value.complexity.score] || "Unknown"), p = D(/* @__PURE__ */ new Set());
+    function r(e) {
+      return p.value.has(e);
+    }
+    function k(e) {
+      p.value.has(e) ? p.value.delete(e) : p.value.add(e);
+    }
+    function C(e) {
+      return e < _.maxExpandedDepth;
+    }
+    function E(e) {
+      return e === null ? "null" : e === void 0 ? "" : typeof e == "string" ? `"${e}"` : Array.isArray(e) ? `[${e.map(E).join(", ")}]` : String(e);
+    }
+    function b(e) {
+      return {
+        exact: "=",
+        wildcard: "*",
+        range: "<>",
+        regex: "/.*/",
+        existence: "?",
+        null_check: "null",
+        cidr: "IP"
+      }[e] || "?";
+    }
+    function N(e) {
+      return `tql-preview__match-type--${e}`;
+    }
+    function S(e) {
+      return `tql-preview__warning--${e}`;
+    }
+    function L(e) {
+      y("field-click", e);
+    }
+    function B(e) {
+      y("node-click", e);
+    }
+    return (e, d) => (i(), o("div", {
+      class: f(["tql-preview", [w.value, { "tql-preview--compact": t.compact, "tql-preview--empty": g.value }]])
+    }, [
+      g.value ? (i(), o("div", F, [...d[0] || (d[0] = [
+        s("span", { class: "tql-preview__empty-text" }, "Enter a query to see preview", -1)
+      ])])) : (i(), o(h, { key: 1 }, [
+        t.showComplexity ? (i(), o("div", O, [
+          s("span", {
+            class: f(["tql-preview__complexity-badge", w.value])
+          }, a(x.value), 3),
+          s("span", V, a(n.value.fieldCount) + " field" + a(n.value.fieldCount !== 1 ? "s" : ""), 1)
+        ])) : u("", !0),
+        t.showComplexity && n.value.complexity.warnings.length > 0 ? (i(), o("div", K, [
+          (i(!0), o(h, null, q(n.value.complexity.warnings, (l, c) => (i(), o("div", {
+            key: c,
+            class: f(["tql-preview__warning", S(l.severity)])
+          }, [
+            s("span", U, a(l.severity === "error" || l.severity === "warning" ? "!" : "i"), 1),
+            s("span", I, a(l.message), 1)
+          ], 2))), 128))
+        ])) : u("", !0),
+        t.showComplexity && n.value.complexity.suggestions.length > 0 ? (i(), o("div", M, [
+          d[1] || (d[1] = s("div", { class: "tql-preview__suggestions-header" }, "Suggestions:", -1)),
+          s("ul", z, [
+            (i(!0), o(h, null, q(n.value.complexity.suggestions, (l, c) => (i(), o("li", {
+              key: c,
+              class: "tql-preview__suggestion"
+            }, a(l), 1))), 128))
+          ])
+        ])) : u("", !0),
+        t.showLogicTree && n.value.logicTree ? (i(), o("div", H, [
+          d[2] || (d[2] = s("div", { class: "tql-preview__tree-header" }, "Query Structure", -1)),
+          s("div", Q, [
+            P(j(le), {
+              node: n.value.logicTree,
+              depth: 0,
+              "node-key": "root",
+              "is-expanded": C(0) || r("root"),
+              "auto-expand-depth": t.maxExpandedDepth,
+              onToggle: k,
+              onNodeClick: B
+            }, null, 8, ["node", "is-expanded", "auto-expand-depth"])
+          ])
+        ])) : u("", !0),
+        t.showFieldUsage && n.value.fields.length > 0 ? (i(), o("div", G, [
+          d[3] || (d[3] = s("div", { class: "tql-preview__fields-header" }, "Fields Used", -1)),
+          s("div", J, [
+            (i(!0), o(h, null, q(n.value.fields, (l, c) => {
+              var T;
+              return i(), o("div", {
+                key: c,
+                class: "tql-preview__field",
+                onClick: (ie) => L(l)
+              }, [
+                s("span", W, a(l.name), 1),
+                (T = l.mutators) != null && T.length ? (i(), o("span", X, " | " + a(l.mutators.join(" | ")), 1)) : u("", !0),
+                s("span", Y, a(l.operator), 1),
+                s("span", Z, a(E(l.value)), 1),
+                s("span", {
+                  class: f(["tql-preview__match-type", N(l.matchType)]),
+                  title: l.matchType
+                }, a(b(l.matchType)), 11, ee)
+              ], 8, R);
+            }), 128))
+          ])
+        ])) : u("", !0),
+        t.showOperatorSummary && Object.keys(n.value.operatorSummary).length > 0 ? (i(), o("div", te, [
+          d[4] || (d[4] = s("div", { class: "tql-preview__operators-header" }, "Operators", -1)),
+          s("div", ne, [
+            (i(!0), o(h, null, q(n.value.operatorSummary, (l, c) => (i(), o("span", {
+              key: c,
+              class: "tql-preview__operator"
+            }, a(c) + ": " + a(l), 1))), 128))
+          ])
+        ])) : u("", !0)
+      ], 64))
+    ], 2));
+  }
+});
+export {
+  le as TqlPreviewNode,
+  re as default
+};

package/dist/vue/composables/useQueryHistory.d.ts

@@ -0,0 +1,35 @@
+import { Ref, ComputedRef } from 'vue';
+import { QueryHistoryEntry, UseQueryHistoryOptions } from '../../src/types';
+
+export interface UseQueryHistoryReturn {
+    /** Reactive array of all history entries */
+    history: Ref<QueryHistoryEntry[]>;
+    /** Computed array of favorited entries */
+    favorites: ComputedRef<QueryHistoryEntry[]>;
+    /** Add a query to history */
+    addQuery: (query: string, metadata?: QueryHistoryEntry["metadata"]) => QueryHistoryEntry;
+    /** Remove a query from history by ID */
+    removeQuery: (id: string) => boolean;
+    /** Clear all history (preserves favorites if specified) */
+    clearHistory: (preserveFavorites?: boolean) => void;
+    /** Toggle favorite status for a query */
+    toggleFavorite: (id: string) => boolean;
+    /** Set a label for a query (used for favorites) */
+    setLabel: (id: string, label: string) => boolean;
+    /** Search history by pattern (matches query text or label) */
+    searchHistory: (pattern: string) => QueryHistoryEntry[];
+    /** Get most recent queries (optionally excluding favorites) */
+    getRecentQueries: (limit?: number, excludeFavorites?: boolean) => QueryHistoryEntry[];
+    /** Get a specific entry by ID */
+    getEntry: (id: string) => QueryHistoryEntry | undefined;
+    /** Update metadata for an entry */
+    updateMetadata: (id: string, metadata: QueryHistoryEntry["metadata"]) => boolean;
+    /** Export history as JSON string */
+    exportHistory: () => string;
+    /** Import history from JSON string */
+    importHistory: (json: string, merge?: boolean) => number;
+    /** Check if storage is available */
+    isStorageAvailable: ComputedRef<boolean>;
+}
+export declare function useQueryHistory(options?: UseQueryHistoryOptions): UseQueryHistoryReturn;
+export type { QueryHistoryEntry, UseQueryHistoryOptions };

package/dist/vue/composables/useQueryHistory.js

@@ -0,0 +1,176 @@
+import { ref as v, watch as Q, computed as d } from "vue";
+const _ = {
+  maxHistory: 100,
+  storageKey: "tql-history",
+  storage: typeof localStorage < "u" ? localStorage : null,
+  deduplicate: !0
+};
+function L(y) {
+  const o = { ..._, ...y }, l = v(!1);
+  try {
+    if (o.storage) {
+      const e = "__tql_storage_test__";
+      o.storage.setItem(e, "test"), o.storage.removeItem(e), l.value = !0;
+    }
+  } catch {
+    l.value = !1;
+  }
+  const r = v([]);
+  if (l.value && o.storage)
+    try {
+      const e = o.storage.getItem(o.storageKey);
+      if (e) {
+        const t = JSON.parse(e);
+        Array.isArray(t) && (r.value = t);
+      }
+    } catch {
+      r.value = [];
+    }
+  Q(
+    r,
+    (e) => {
+      if (l.value && o.storage)
+        try {
+          o.storage.setItem(o.storageKey, JSON.stringify(e));
+        } catch (t) {
+          if (t instanceof Error && t.name === "QuotaExceededError") {
+            const i = e.filter((a) => !a.isFavorite);
+            if (i.length > 0) {
+              const a = i.slice(0, Math.ceil(i.length / 2));
+              r.value = e.filter(
+                (n) => !a.some((s) => s.id === n.id)
+              );
+            }
+          }
+        }
+    },
+    { deep: !0 }
+  );
+  const m = d(
+    () => r.value.filter((e) => e.isFavorite)
+  ), g = d(() => l.value);
+  function f() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  function p(e, t) {
+    const i = e.trim();
+    if (!i)
+      throw new Error("Cannot add empty query to history");
+    if (o.deduplicate) {
+      const n = r.value.findIndex((s) => s.query === i);
+      if (n !== -1) {
+        const s = r.value[n];
+        r.value.splice(n, 1);
+        const u = {
+          ...s,
+          timestamp: Date.now(),
+          metadata: { ...s.metadata, ...t }
+        };
+        return r.value.unshift(u), u;
+      }
+    }
+    const a = {
+      id: f(),
+      query: i,
+      timestamp: Date.now(),
+      isFavorite: !1,
+      metadata: t
+    };
+    return r.value.unshift(a), c(), a;
+  }
+  function c() {
+    const e = r.value.filter((t) => !t.isFavorite);
+    if (e.length > o.maxHistory) {
+      const t = e.length - o.maxHistory, i = new Set(
+        e.slice(-t).map((a) => a.id)
+      );
+      r.value = r.value.filter((a) => !i.has(a.id));
+    }
+  }
+  function h(e) {
+    const t = r.value.findIndex((i) => i.id === e);
+    return t === -1 ? !1 : (r.value.splice(t, 1), !0);
+  }
+  function x(e = !1) {
+    e ? r.value = r.value.filter((t) => t.isFavorite) : r.value = [];
+  }
+  function w(e) {
+    const t = r.value.find((i) => i.id === e);
+    return t ? (t.isFavorite = !t.isFavorite, !0) : !1;
+  }
+  function F(e, t) {
+    const i = r.value.find((a) => a.id === e);
+    return i ? (i.label = t.trim() || void 0, !0) : !1;
+  }
+  function S(e) {
+    if (!e.trim())
+      return [...r.value];
+    const t = e.toLowerCase();
+    return r.value.filter((i) => {
+      var a;
+      return !!(i.query.toLowerCase().includes(t) || (a = i.label) != null && a.toLowerCase().includes(t));
+    });
+  }
+  function E(e = 10, t = !1) {
+    let i = [...r.value];
+    return t && (i = i.filter((a) => !a.isFavorite)), i.sort((a, n) => n.timestamp - a.timestamp), i.slice(0, e);
+  }
+  function I(e) {
+    return r.value.find((t) => t.id === e);
+  }
+  function b(e, t) {
+    const i = r.value.find((a) => a.id === e);
+    return i ? (i.metadata = { ...i.metadata, ...t }, !0) : !1;
+  }
+  function q() {
+    return JSON.stringify(r.value, null, 2);
+  }
+  function H(e, t = !0) {
+    try {
+      const i = JSON.parse(e);
+      if (!Array.isArray(i))
+        throw new Error("Invalid history format: expected array");
+      const a = [];
+      for (const n of i)
+        A(n) && a.push({
+          ...n,
+          id: f()
+        });
+      if (t) {
+        const n = new Set(r.value.map((u) => u.query)), s = a.filter(
+          (u) => !n.has(u.query)
+        );
+        r.value = [...r.value, ...s];
+      } else
+        r.value = a;
+      return c(), a.length;
+    } catch {
+      return 0;
+    }
+  }
+  function A(e) {
+    if (typeof e != "object" || e === null)
+      return !1;
+    const t = e;
+    return typeof t.query == "string" && typeof t.timestamp == "number" && typeof t.isFavorite == "boolean";
+  }
+  return {
+    history: r,
+    favorites: m,
+    addQuery: p,
+    removeQuery: h,
+    clearHistory: x,
+    toggleFavorite: w,
+    setLabel: F,
+    searchHistory: S,
+    getRecentQueries: E,
+    getEntry: I,
+    updateMetadata: b,
+    exportHistory: q,
+    importHistory: H,
+    isStorageAvailable: g
+  };
+}
+export {
+  L as useQueryHistory
+};

package/dist/vue/index.d.ts

@@ -7,4 +7,6 @@
  */
 export { default as TqlInput } from './TqlInput.vue';
 export { default as TqlAutocomplete } from './TqlAutocomplete.vue';
+export { default as TqlPreview } from './components/TqlPreview.vue';
 export { useTqlInput, type UseTqlInputOptions } from './useTqlInput';
+export { useQueryHistory, type UseQueryHistoryReturn, type QueryHistoryEntry, type UseQueryHistoryOptions } from './composables/useQueryHistory';

package/dist/vue/index.js

@@ -1,8 +1,12 @@
-import { default as o } from "./TqlInput.vue.js";
-import { default as p } from "./TqlAutocomplete.vue.js";
-import { useTqlInput as u } from "./useTqlInput.js";
+import { default as r } from "./TqlInput.vue.js";
+import { default as u } from "./TqlAutocomplete.vue.js";
+import { default as l } from "./components/TqlPreview.vue.js";
+import { useTqlInput as a } from "./useTqlInput.js";
+import { useQueryHistory as s } from "./composables/useQueryHistory.js";
 export {
-  p as TqlAutocomplete,
-  o as TqlInput,
-  u as useTqlInput
+  u as TqlAutocomplete,
+  r as TqlInput,
+  l as TqlPreview,
+  s as useQueryHistory,
+  a as useTqlInput
 };