@tellaro/tql 2.0.0 → 3.0.0

package/dist/vue/TqlInput.vue.d.ts

@@ -1,2 +1,93 @@
-declare const _default: any;
+import { TqlCompletionItem, TqlInputProps, TqlParseResult, TqlSnippet, TqlToken, TqlValidationResult } from '../src/types';
+declare const _default: import('vue').DefineComponent<TqlInputProps, {
+    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;
+    isValid: boolean;
+    hasErrors: boolean;
+    errors: import('../src').TqlParseError[];
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+    validation: (result: TqlValidationResult) => any;
+    parse: (result: TqlParseResult) => any;
+    submit: (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<TqlInputProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    onValidation?: ((result: TqlValidationResult) => any) | undefined;
+    onParse?: ((result: TqlParseResult) => any) | undefined;
+    onSubmit?: ((value: string) => any) | undefined;
+}>, {
+    disabled: boolean;
+    placeholder: string;
+    showComplexity: boolean;
+    validateOnInput: boolean;
+    debounceMs: number;
+    autocomplete: boolean;
+    readonly: boolean;
+    rows: number;
+    multiline: boolean;
+    showValidation: boolean;
+    showSnippetButton: boolean;
+    syntaxHighlighting: boolean;
+    alwaysShowErrors: boolean;
+    resizable: boolean;
+    minHeight: string;
+    showHistory: boolean;
+    showPreview: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    wrapperRef: HTMLDivElement;
+    highlightRef: HTMLDivElement;
+    inputRef: HTMLInputElement;
+    autocompleteRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        id?: string;
+        items: TqlCompletionItem[];
+        visible: boolean;
+        position: {
+            top: number;
+            left: number;
+        };
+        maxHeight?: number;
+    }> & Readonly<{
+        onSelect?: ((item: TqlCompletionItem) => any) | undefined;
+        onClose?: (() => any) | undefined;
+    }>, {
+        selectCurrent: () => void;
+        moveUp: () => void;
+        moveDown: () => void;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        select: (item: TqlCompletionItem) => any;
+        close: () => any;
+    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        listRef: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        id?: string;
+        items: TqlCompletionItem[];
+        visible: boolean;
+        position: {
+            top: number;
+            left: number;
+        };
+        maxHeight?: number;
+    }> & Readonly<{
+        onSelect?: ((item: TqlCompletionItem) => any) | undefined;
+        onClose?: (() => any) | undefined;
+    }>, {
+        selectCurrent: () => void;
+        moveUp: () => void;
+        moveDown: () => void;
+    }, {}, {}, {}, {}> | null;
+    validationMessagesRef: HTMLDivElement;
+}, HTMLDivElement>;
 export default _default;

package/dist/vue/TqlInput.vue.js

@@ -2,7 +2,7 @@ import o from "./TqlInput.vue2.js";
 /* empty css              */
 /* empty css              */
 import t from "../_virtual/_plugin-vue_export-helper.js";
-const _ = /* @__PURE__ */ t(o, [["__scopeId", "data-v-7ce615f9"]]);
+const _ = /* @__PURE__ */ t(o, [["__scopeId", "data-v-d513cd4d"]]);
 export {
   _ as default
 };

package/dist/vue/TqlInput.vue2.js

@@ -358,10 +358,17 @@ const ht = ["placeholder", "disabled", "readonly", "rows", "aria-expanded", "ari
       getTokenAtPosition: Ae,
       getCursorPosition: Se,
       setCursorPosition: Ce,
-      // Reactive state for form validation
-      isValid: G,
-      hasErrors: D,
-      errors: R
+      // Reactive state for form validation. Getters, so the exposed value is live
+      // and matches TqlInputExpose; Vue would unwrap a ref here anyway.
+      get isValid() {
+        return G.value;
+      },
+      get hasErrors() {
+        return D.value;
+      },
+      get errors() {
+        return R.value;
+      }
     });
     function ee() {
       (x.value || D.value) && k.value && Y();

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

@@ -1,4 +1,91 @@
-declare const TqlPreviewNode: any;
+import { FieldUsage, LogicTreeNode } from '../../src/types';
+import { PropType } from 'vue';
+export interface Props {
+    /** The TQL query to preview */
+    query: string;
+    /** Whether to show the logic tree (default: true) */
+    showLogicTree?: boolean;
+    /** Whether to show field usage list (default: true) */
+    showFieldUsage?: boolean;
+    /** Whether to show complexity warnings (default: true) */
+    showComplexity?: boolean;
+    /** Whether to show operator summary (default: false) */
+    showOperatorSummary?: boolean;
+    /** Maximum depth to expand in logic tree (default: 3) */
+    maxExpandedDepth?: number;
+    /** Compact mode for smaller display (default: false) */
+    compact?: boolean;
+}
+declare const TqlPreviewNode: import('vue').DefineComponent<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<LogicTreeNode>;
+        required: true;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    nodeKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    isExpanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandDepth: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, {
+    hasChildren: import('vue').ComputedRef<boolean | undefined>;
+    nodeLabel: import('vue').ComputedRef<string>;
+    handleToggle: () => void;
+    handleClick: () => void;
+    getChildKey: (index: number) => string;
+    shouldChildExpand: (_childIndex: number) => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, ("toggle" | "node-click")[], "toggle" | "node-click", import('vue').PublicProps, Readonly<import('vue').ExtractPropTypes<{
+    node: {
+        type: PropType<LogicTreeNode>;
+        required: true;
+    };
+    depth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    nodeKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    isExpanded: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    autoExpandDepth: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    onToggle?: ((...args: any[]) => any) | undefined;
+    "onNode-click"?: ((...args: any[]) => any) | undefined;
+}>, {
+    depth: number;
+    isExpanded: boolean;
+    autoExpandDepth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
 export { TqlPreviewNode };
-declare const _default: any;
+declare const _default: import('vue').DefineComponent<Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "node-click": (node: LogicTreeNode) => any;
+    "field-click": (field: FieldUsage) => any;
+}, string, import('vue').PublicProps, Readonly<Props> & Readonly<{
+    "onNode-click"?: ((node: LogicTreeNode) => any) | undefined;
+    "onField-click"?: ((field: FieldUsage) => any) | undefined;
+}>, {
+    showLogicTree: boolean;
+    showFieldUsage: boolean;
+    showComplexity: boolean;
+    showOperatorSummary: boolean;
+    maxExpandedDepth: number;
+    compact: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
 export default _default;

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

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

package/dist/vue/index.d.ts

@@ -9,5 +9,5 @@ export { default as TqlInput } from './TqlInput.vue';
 export { default as TqlAutocomplete } from './TqlAutocomplete.vue';
 export { default as TqlPreview } from './components/TqlPreview.vue';
 export { default as TqlChart } from './TqlChart.vue';
-export { useTqlInput, type UseTqlInputOptions } from './useTqlInput';
+export { useTqlInput, type UseTqlInputOptions, type UseTqlInputReturn } from './useTqlInput';
 export { useQueryHistory, type UseQueryHistoryReturn, type QueryHistoryEntry, type UseQueryHistoryOptions } from './composables/useQueryHistory';

package/dist/vue/useTqlInput.d.ts

@@ -1,5 +1,5 @@
-import { Ref } from 'vue';
-import { TqlCompletionItem, TqlFieldSchema, TqlParseResult, TqlSnippet, TqlToken, TqlValidationResult } from '../src/types';
+import { ComputedRef, Ref } from 'vue';
+import { TqlCompletionItem, TqlFieldSchema, TqlParseError, TqlParseResult, TqlParseWarning, TqlSnippet, TqlToken, TqlValidationResult } from '../src/types';
 export interface UseTqlInputOptions {
     modelValue: Ref<string>;
     fieldSchema?: Ref<TqlFieldSchema[] | undefined>;
@@ -21,34 +21,43 @@ export interface PlaceholderPosition {
     start: number;
     end: number;
 }
-export declare function useTqlInput(options: UseTqlInputOptions): {
-    tokens: any;
-    parseResult: any;
-    validationResult: any;
-    cursorPosition: any;
-    completionItems: any;
-    showAutocomplete: any;
-    isValidating: any;
-    isValid: any;
-    errors: any;
-    warnings: any;
-    hasErrors: any;
-    hasWarnings: any;
-    tokenize: () => any;
-    parse: () => TqlParseResult;
-    validate: () => TqlValidationResult;
-    updateCompletions: () => void;
-    triggerAutocomplete: () => void;
-    hideAutocomplete: () => void;
-    handleInput: (value: string) => void;
-    handleCursorChange: (position: number) => void;
-    insertCompletion: (item: TqlCompletionItem) => {
+/**
+ * What `useTqlInput` returns.
+ *
+ * Spelled out rather than inferred: with `declaration: true` the inferred type
+ * of the returned object (every `Ref<UnwrapRef<...>>` expanded) exceeds what the
+ * compiler will serialize (TS7056), so vue-tsc refused to type-check the package
+ * and no declaration for this composable could be emitted.
+ */
+export interface UseTqlInputReturn {
+    tokens: Ref<TqlToken[]>;
+    parseResult: Ref<TqlParseResult | null>;
+    validationResult: Ref<TqlValidationResult | null>;
+    cursorPosition: Ref<number>;
+    completionItems: Ref<TqlCompletionItem[]>;
+    showAutocomplete: Ref<boolean>;
+    isValidating: Ref<boolean>;
+    isValid: ComputedRef<boolean>;
+    errors: ComputedRef<TqlParseError[]>;
+    warnings: ComputedRef<TqlParseWarning[]>;
+    hasErrors: ComputedRef<boolean>;
+    hasWarnings: ComputedRef<boolean>;
+    tokenize(): TqlToken[];
+    parse(): TqlParseResult;
+    validate(): TqlValidationResult;
+    updateCompletions(): void;
+    triggerAutocomplete(): void;
+    hideAutocomplete(): void;
+    handleInput(value: string): void;
+    handleCursorChange(position: number): void;
+    insertCompletion(item: TqlCompletionItem): {
         query: string;
         newCursorPosition: number;
         placeholders: PlaceholderPosition[];
     };
-    insertSnippet: (snippet: TqlSnippet) => string;
-    getTokenAtCursor: () => TqlToken | null;
-    isPositionInError: (position: number) => boolean;
-    getErrorsAtPosition: (position: number) => any;
-};
+    insertSnippet(snippet: TqlSnippet): string;
+    getTokenAtCursor(): TqlToken | null;
+    isPositionInError(position: number): boolean;
+    getErrorsAtPosition(position: number): TqlParseError[];
+}
+export declare function useTqlInput(options: UseTqlInputOptions): UseTqlInputReturn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tellaro/tql",
-  "version": "2.0.0",
+  "version": "3.0.0",
   "description": "Tellaro Query Language (TQL) parser, validator, and autocomplete for JavaScript/TypeScript",
   "type": "module",
   "main": "./dist/index.js",
@@ -36,7 +36,6 @@
     "test:e2e:ui": "playwright test --ui",
     "playground:serve": "vite --config vite.playground.config.ts --port 5174",
     "playground:dev": "vite --config vite.playground.config.ts",
-    "lint": "eslint src vue tests --ext .ts,.vue",
     "typecheck": "vue-tsc --noEmit",
     "prepublishOnly": "npm run build"
   },
@@ -102,14 +101,13 @@
     "chartjs-adapter-luxon": "^1.3.1",
     "chartjs-plugin-annotation": "^3.1.0",
     "chartjs-plugin-datalabels": "^2.2.0",
-    "eslint": "^8.56.0",
-    "js-yaml": "^4.1.0",
+    "js-yaml": "^4.3.2",
     "jsdom": "^24.0.0",
     "luxon": "^3.7.2",
     "typescript": "^5.3.0",
     "vite": "^7.3.2",
     "vite-plugin-dts": "^4.5.4",
-    "vitest": "^4.0.18",
+    "vitest": "^4.1.11",
     "vue": "^3.4.0",
     "vue-tsc": "^3.2.4"
   },