@standardbeagle/dart-query 0.3.2

package/dist/parsers/dartql.js

@@ -0,0 +1,889 @@
+import { DartQLParseError } from '../types/index.js';
+export var TokenType;
+(function (TokenType) {
+    TokenType["IDENTIFIER"] = "IDENTIFIER";
+    TokenType["STRING"] = "STRING";
+    TokenType["NUMBER"] = "NUMBER";
+    TokenType["EQUALS"] = "EQUALS";
+    TokenType["NOT_EQUALS"] = "NOT_EQUALS";
+    TokenType["GREATER_THAN"] = "GREATER_THAN";
+    TokenType["GREATER_EQUAL"] = "GREATER_EQUAL";
+    TokenType["LESS_THAN"] = "LESS_THAN";
+    TokenType["LESS_EQUAL"] = "LESS_EQUAL";
+    TokenType["AND"] = "AND";
+    TokenType["OR"] = "OR";
+    TokenType["NOT"] = "NOT";
+    TokenType["IN"] = "IN";
+    TokenType["LIKE"] = "LIKE";
+    TokenType["CONTAINS"] = "CONTAINS";
+    TokenType["IS"] = "IS";
+    TokenType["NULL"] = "NULL";
+    TokenType["BETWEEN"] = "BETWEEN";
+    TokenType["LPAREN"] = "LPAREN";
+    TokenType["RPAREN"] = "RPAREN";
+    TokenType["COMMA"] = "COMMA";
+    TokenType["EOF"] = "EOF";
+    TokenType["UNKNOWN"] = "UNKNOWN";
+})(TokenType || (TokenType = {}));
+export const VALID_FIELDS = [
+    'status',
+    'priority',
+    'size',
+    'title',
+    'description',
+    'assignee',
+    'dartboard',
+    'tags',
+    'created_at',
+    'updated_at',
+    'due_at',
+    'start_at',
+    'completed_at',
+    'parent_task',
+    'dart_id',
+    'subtask_ids',
+    'blocker_ids',
+    'blocking_ids',
+    'duplicate_ids',
+    'related_ids',
+];
+export class DartQLTokenizer {
+    input;
+    position;
+    tokens;
+    constructor(input) {
+        this.input = input.trim();
+        this.position = 0;
+        this.tokens = [];
+    }
+    tokenize() {
+        this.tokens = [];
+        this.position = 0;
+        while (this.position < this.input.length) {
+            this.skipWhitespace();
+            if (this.position >= this.input.length) {
+                break;
+            }
+            const token = this.nextToken();
+            if (token) {
+                this.tokens.push(token);
+            }
+        }
+        this.tokens.push({
+            type: TokenType.EOF,
+            value: '',
+            position: this.position,
+            length: 0,
+        });
+        return this.tokens;
+    }
+    skipWhitespace() {
+        while (this.position < this.input.length && /\s/.test(this.input[this.position])) {
+            this.position++;
+        }
+    }
+    peek(offset = 0) {
+        const pos = this.position + offset;
+        return pos < this.input.length ? this.input[pos] : '';
+    }
+    consume() {
+        if (this.position >= this.input.length) {
+            return '';
+        }
+        return this.input[this.position++];
+    }
+    isAtEnd() {
+        return this.position >= this.input.length;
+    }
+    nextToken() {
+        const start = this.position;
+        const char = this.peek();
+        if (char === '"' || char === "'") {
+            return this.readString();
+        }
+        if (/\d/.test(char)) {
+            return this.readNumber();
+        }
+        if (char === '=' || char === '!' || char === '>' || char === '<') {
+            return this.readOperator();
+        }
+        if (char === '(') {
+            this.consume();
+            return { type: TokenType.LPAREN, value: '(', position: start, length: 1 };
+        }
+        if (char === ')') {
+            this.consume();
+            return { type: TokenType.RPAREN, value: ')', position: start, length: 1 };
+        }
+        if (char === ',') {
+            this.consume();
+            return { type: TokenType.COMMA, value: ',', position: start, length: 1 };
+        }
+        if (/[a-zA-Z_]/.test(char)) {
+            return this.readIdentifierOrKeyword();
+        }
+        throw new DartQLParseError(`Unexpected character: '${char}'`, this.position, char);
+    }
+    readString() {
+        const start = this.position;
+        const quote = this.consume();
+        let value = '';
+        while (!this.isAtEnd() && this.peek() !== quote) {
+            const char = this.consume();
+            if (char === '\\' && !this.isAtEnd()) {
+                const next = this.consume();
+                switch (next) {
+                    case 'n':
+                        value += '\n';
+                        break;
+                    case 't':
+                        value += '\t';
+                        break;
+                    case 'r':
+                        value += '\r';
+                        break;
+                    case '\\':
+                        value += '\\';
+                        break;
+                    case quote:
+                        value += quote;
+                        break;
+                    default: value += next;
+                }
+            }
+            else {
+                value += char;
+            }
+        }
+        if (this.isAtEnd()) {
+            throw new DartQLParseError(`Unterminated string literal starting at position ${start}`, start, quote);
+        }
+        this.consume();
+        const length = this.position - start;
+        return {
+            type: TokenType.STRING,
+            value,
+            position: start,
+            length,
+        };
+    }
+    readNumber() {
+        const start = this.position;
+        let value = '';
+        while (!this.isAtEnd() && /\d/.test(this.peek())) {
+            value += this.consume();
+        }
+        if (this.peek() === '.' && /\d/.test(this.peek(1))) {
+            value += this.consume();
+            while (!this.isAtEnd() && /\d/.test(this.peek())) {
+                value += this.consume();
+            }
+        }
+        const length = this.position - start;
+        return {
+            type: TokenType.NUMBER,
+            value,
+            position: start,
+            length,
+        };
+    }
+    readOperator() {
+        const start = this.position;
+        const first = this.consume();
+        const second = this.peek();
+        if (first === '!' && second === '=') {
+            this.consume();
+            return { type: TokenType.NOT_EQUALS, value: '!=', position: start, length: 2 };
+        }
+        if (first === '>' && second === '=') {
+            this.consume();
+            return { type: TokenType.GREATER_EQUAL, value: '>=', position: start, length: 2 };
+        }
+        if (first === '<' && second === '=') {
+            this.consume();
+            return { type: TokenType.LESS_EQUAL, value: '<=', position: start, length: 2 };
+        }
+        if (first === '=') {
+            return { type: TokenType.EQUALS, value: '=', position: start, length: 1 };
+        }
+        if (first === '>') {
+            return { type: TokenType.GREATER_THAN, value: '>', position: start, length: 1 };
+        }
+        if (first === '<') {
+            return { type: TokenType.LESS_THAN, value: '<', position: start, length: 1 };
+        }
+        throw new DartQLParseError(`Invalid operator starting with '${first}'`, start, first);
+    }
+    readIdentifierOrKeyword() {
+        const start = this.position;
+        let value = '';
+        while (!this.isAtEnd() && /[a-zA-Z0-9_]/.test(this.peek())) {
+            value += this.consume();
+        }
+        const length = this.position - start;
+        const upperValue = value.toUpperCase();
+        const keywordMap = {
+            'AND': TokenType.AND,
+            'OR': TokenType.OR,
+            'NOT': TokenType.NOT,
+            'IN': TokenType.IN,
+            'LIKE': TokenType.LIKE,
+            'CONTAINS': TokenType.CONTAINS,
+            'IS': TokenType.IS,
+            'NULL': TokenType.NULL,
+            'BETWEEN': TokenType.BETWEEN,
+        };
+        const type = keywordMap[upperValue] || TokenType.IDENTIFIER;
+        return {
+            type,
+            value,
+            position: start,
+            length,
+        };
+    }
+}
+export class DartQLLexer {
+    tokens;
+    errors;
+    fields;
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.errors = [];
+        this.fields = new Set();
+    }
+    analyze() {
+        this.errors = [];
+        this.fields = new Set();
+        for (let i = 0; i < this.tokens.length; i++) {
+            const token = this.tokens[i];
+            if (token.type === TokenType.IDENTIFIER) {
+                this.validateFieldName(token);
+            }
+            if (token.type === TokenType.NOT) {
+                const next = this.tokens[i + 1];
+                if (next && next.type === TokenType.IN) {
+                    continue;
+                }
+                else if (next && next.type === TokenType.LPAREN) {
+                    continue;
+                }
+            }
+            if (token.type === TokenType.IS) {
+                const next = this.tokens[i + 1];
+                if (!next || (next.type !== TokenType.NULL && next.type !== TokenType.NOT)) {
+                    this.errors.push(`IS keyword must be followed by NULL or NOT NULL at position ${token.position}`);
+                }
+            }
+        }
+        return {
+            tokens: this.tokens,
+            errors: this.errors,
+            fields: Array.from(this.fields),
+        };
+    }
+    validateFieldName(token) {
+        const fieldName = token.value.toLowerCase();
+        this.fields.add(fieldName);
+        if (!VALID_FIELDS.includes(fieldName)) {
+            const suggestion = this.findClosestField(fieldName);
+            if (suggestion) {
+                this.errors.push(`Unknown field: '${token.value}'. Did you mean '${suggestion}'? (at position ${token.position})`);
+            }
+            else {
+                this.errors.push(`Unknown field: '${token.value}'. Valid fields: ${VALID_FIELDS.join(', ')} (at position ${token.position})`);
+            }
+        }
+    }
+    findClosestField(input) {
+        const threshold = 2;
+        let closest = null;
+        let minDistance = Infinity;
+        for (const field of VALID_FIELDS) {
+            const distance = this.levenshteinDistance(input, field);
+            if (distance < minDistance && distance <= threshold) {
+                minDistance = distance;
+                closest = field;
+            }
+        }
+        return closest;
+    }
+    levenshteinDistance(a, b) {
+        const matrix = [];
+        for (let i = 0; i <= b.length; i++) {
+            matrix[i] = [i];
+        }
+        for (let j = 0; j <= a.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= b.length; i++) {
+            for (let j = 1; j <= a.length; j++) {
+                if (b.charAt(i - 1) === a.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[b.length][a.length];
+    }
+}
+export class DartQLParser {
+    tokens;
+    position;
+    errors;
+    fields;
+    constructor(tokens) {
+        this.tokens = tokens;
+        this.position = 0;
+        this.errors = [];
+        this.fields = new Set();
+    }
+    parse() {
+        this.position = 0;
+        this.errors = [];
+        this.fields = new Set();
+        if (this.tokens.length === 1 && this.tokens[0].type === TokenType.EOF) {
+            this.errors.push('Empty query - no expression to parse');
+            return {
+                ast: { type: 'group', expressions: [] },
+                fields: [],
+                errors: this.errors,
+            };
+        }
+        try {
+            const ast = this.parseExpression();
+            if (this.current().type !== TokenType.EOF) {
+                this.addError(`Unexpected token: '${this.current().value}' at position ${this.current().position}`);
+            }
+            return {
+                ast,
+                fields: Array.from(this.fields),
+                errors: this.errors,
+            };
+        }
+        catch (error) {
+            if (error instanceof DartQLParseError) {
+                this.errors.push(error.message);
+            }
+            else {
+                this.errors.push(`Parse error: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            return {
+                ast: { type: 'group', expressions: [] },
+                fields: Array.from(this.fields),
+                errors: this.errors,
+            };
+        }
+    }
+    current() {
+        return this.tokens[this.position] || this.tokens[this.tokens.length - 1];
+    }
+    peek(offset = 1) {
+        const pos = this.position + offset;
+        return this.tokens[pos] || this.tokens[this.tokens.length - 1];
+    }
+    consume() {
+        const token = this.current();
+        if (token.type !== TokenType.EOF) {
+            this.position++;
+        }
+        return token;
+    }
+    match(...types) {
+        return types.includes(this.current().type);
+    }
+    expect(type, errorMessage) {
+        if (!this.match(type)) {
+            this.addError(errorMessage + ` at position ${this.current().position}`);
+            throw new DartQLParseError(errorMessage, this.current().position, this.current().value);
+        }
+        return this.consume();
+    }
+    addError(message) {
+        this.errors.push(message);
+    }
+    parseExpression() {
+        let left = this.parseAndExpression();
+        while (this.match(TokenType.OR)) {
+            this.consume();
+            const right = this.parseAndExpression();
+            left = {
+                type: 'logical',
+                operator: 'OR',
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    parseAndExpression() {
+        let left = this.parseNotExpression();
+        while (this.match(TokenType.AND)) {
+            this.consume();
+            const right = this.parseNotExpression();
+            left = {
+                type: 'logical',
+                operator: 'AND',
+                left,
+                right,
+            };
+        }
+        return left;
+    }
+    parseNotExpression() {
+        if (this.match(TokenType.NOT)) {
+            this.consume();
+            if (this.match(TokenType.IN)) {
+                this.position--;
+                return this.parsePrimary();
+            }
+            const expression = this.parseNotExpression();
+            return {
+                type: 'logical',
+                operator: 'NOT',
+                right: expression,
+            };
+        }
+        return this.parsePrimary();
+    }
+    parsePrimary() {
+        if (this.match(TokenType.LPAREN)) {
+            this.consume();
+            const expression = this.parseExpression();
+            this.expect(TokenType.RPAREN, 'Expected closing parenthesis');
+            return {
+                type: 'group',
+                expressions: [expression],
+            };
+        }
+        return this.parseComparison();
+    }
+    parseComparison() {
+        const fieldToken = this.expect(TokenType.IDENTIFIER, 'Expected field name');
+        const field = fieldToken.value.toLowerCase();
+        this.fields.add(field);
+        if (this.match(TokenType.IS)) {
+            this.consume();
+            const isNot = this.match(TokenType.NOT);
+            if (isNot) {
+                this.consume();
+            }
+            this.expect(TokenType.NULL, 'Expected NULL after IS or IS NOT');
+            return {
+                type: 'comparison',
+                field,
+                operator: isNot ? 'IS NOT NULL' : 'IS NULL',
+                value: null,
+            };
+        }
+        if (this.match(TokenType.NOT)) {
+            const next = this.peek();
+            if (next.type === TokenType.IN) {
+                this.consume();
+                this.consume();
+                const value = this.parseInArray();
+                return {
+                    type: 'comparison',
+                    field,
+                    operator: 'NOT IN',
+                    value,
+                };
+            }
+        }
+        if (this.match(TokenType.IN)) {
+            this.consume();
+            const value = this.parseInArray();
+            return {
+                type: 'comparison',
+                field,
+                operator: 'IN',
+                value,
+            };
+        }
+        if (this.match(TokenType.BETWEEN)) {
+            this.consume();
+            const start = this.parseValue();
+            this.expect(TokenType.AND, 'Expected AND in BETWEEN clause');
+            const end = this.parseValue();
+            return {
+                type: 'comparison',
+                field,
+                operator: 'BETWEEN',
+                value: [start, end],
+            };
+        }
+        const operator = this.parseOperator();
+        const value = this.parseValue();
+        return {
+            type: 'comparison',
+            field,
+            operator,
+            value,
+        };
+    }
+    parseOperator() {
+        const token = this.current();
+        const operatorMap = {
+            [TokenType.EQUALS]: '=',
+            [TokenType.NOT_EQUALS]: '!=',
+            [TokenType.GREATER_THAN]: '>',
+            [TokenType.GREATER_EQUAL]: '>=',
+            [TokenType.LESS_THAN]: '<',
+            [TokenType.LESS_EQUAL]: '<=',
+            [TokenType.LIKE]: 'LIKE',
+            [TokenType.CONTAINS]: 'CONTAINS',
+        };
+        const operator = operatorMap[token.type];
+        if (!operator) {
+            this.addError(`Expected comparison operator, got '${token.value}' at position ${token.position}`);
+            throw new DartQLParseError(`Expected comparison operator`, token.position, token.value);
+        }
+        this.consume();
+        return operator;
+    }
+    parseValue() {
+        const token = this.current();
+        if (token.type === TokenType.STRING) {
+            this.consume();
+            return token.value;
+        }
+        if (token.type === TokenType.NUMBER) {
+            this.consume();
+            return parseFloat(token.value);
+        }
+        if (token.type === TokenType.NULL) {
+            this.consume();
+            return null;
+        }
+        this.addError(`Expected value (string, number, or NULL), got '${token.value}' at position ${token.position}`);
+        throw new DartQLParseError('Expected value', token.position, token.value);
+    }
+    parseInArray() {
+        this.expect(TokenType.LPAREN, 'Expected opening parenthesis for IN clause');
+        const values = [];
+        if (this.match(TokenType.RPAREN)) {
+            this.consume();
+            return values;
+        }
+        values.push(this.parseValue());
+        while (this.match(TokenType.COMMA)) {
+            this.consume();
+            values.push(this.parseValue());
+        }
+        this.expect(TokenType.RPAREN, 'Expected closing parenthesis for IN clause');
+        return values;
+    }
+}
+export function parseDartQLToAST(input) {
+    try {
+        const tokenizer = new DartQLTokenizer(input);
+        const tokens = tokenizer.tokenize();
+        const lexer = new DartQLLexer(tokens);
+        const lexerResult = lexer.analyze();
+        if (lexerResult.errors.length > 0) {
+            return {
+                ast: { type: 'group', expressions: [] },
+                fields: lexerResult.fields,
+                errors: lexerResult.errors,
+            };
+        }
+        const parser = new DartQLParser(tokens);
+        const parseResult = parser.parse();
+        return parseResult;
+    }
+    catch (error) {
+        if (error instanceof DartQLParseError) {
+            return {
+                ast: { type: 'group', expressions: [] },
+                fields: [],
+                errors: [error.message],
+            };
+        }
+        throw error;
+    }
+}
+export function convertToFilters(ast) {
+    const result = {
+        apiFilters: {},
+        requiresClientSide: false,
+        warnings: [],
+        errors: [],
+    };
+    try {
+        const analysis = analyzeAST(ast);
+        if (analysis.canUseAPI) {
+            result.apiFilters = extractAPIFilters(ast);
+        }
+        else {
+            result.requiresClientSide = true;
+            result.clientFilter = buildClientSideFilter(ast);
+            result.warnings.push('Query requires client-side filtering which may impact performance. ' +
+                'Consider using simpler queries with API-supported filters for better performance.');
+            if (analysis.reasons.length > 0) {
+                result.warnings.push(...analysis.reasons);
+            }
+        }
+    }
+    catch (error) {
+        result.errors.push(`Failed to convert AST to filters: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    return result;
+}
+function analyzeAST(ast) {
+    const reasons = [];
+    const canUseAPI = isAPICompatible(ast, reasons);
+    return { canUseAPI, reasons };
+}
+function isAPICompatible(expr, reasons) {
+    if (expr.type === 'comparison') {
+        const field = expr.field?.toLowerCase();
+        const operator = expr.operator;
+        const apiSupportedFields = ['assignee', 'status', 'dartboard', 'priority', 'tags', 'due_at'];
+        if (field && !apiSupportedFields.includes(field)) {
+            reasons.push(`Field '${field}' not supported by API filters`);
+            return false;
+        }
+        if (operator === 'IN' || operator === 'NOT IN') {
+            reasons.push(`${operator} operator requires client-side filtering`);
+            return false;
+        }
+        if (operator === 'LIKE' || operator === 'CONTAINS') {
+            reasons.push(`${operator} operator requires client-side filtering`);
+            return false;
+        }
+        if (operator === 'IS NULL' || operator === 'IS NOT NULL') {
+            reasons.push(`${operator} operator requires client-side filtering`);
+            return false;
+        }
+        if (operator === 'BETWEEN') {
+            reasons.push(`BETWEEN operator requires client-side filtering`);
+            return false;
+        }
+        if (field === 'priority' && (operator === '>' || operator === '>=' || operator === '<' || operator === '<=')) {
+            reasons.push(`Range operators on 'priority' require client-side filtering (API only supports equality)`);
+            return false;
+        }
+        if (field === 'due_at') {
+            if (operator === '<' || operator === '<=') {
+                return true;
+            }
+            if (operator === '>' || operator === '>=') {
+                return true;
+            }
+            if (operator === '=' || operator === '!=') {
+                reasons.push(`Equality operators on 'due_at' require client-side filtering`);
+                return false;
+            }
+        }
+        if (operator !== '=' && operator !== '!=') {
+            reasons.push(`Operator '${operator}' not supported by API for field '${field}'`);
+            return false;
+        }
+        if (operator === '!=') {
+            reasons.push(`!= operator requires client-side filtering`);
+            return false;
+        }
+        return true;
+    }
+    if (expr.type === 'logical') {
+        if (expr.operator === 'OR') {
+            reasons.push('OR logic requires client-side filtering (API only supports AND)');
+            return false;
+        }
+        if (expr.operator === 'NOT') {
+            reasons.push('NOT logic requires client-side filtering');
+            return false;
+        }
+        if (expr.operator === 'AND') {
+            const leftOk = expr.left ? isAPICompatible(expr.left, reasons) : false;
+            const rightOk = expr.right ? isAPICompatible(expr.right, reasons) : false;
+            return leftOk && rightOk;
+        }
+    }
+    if (expr.type === 'group') {
+        if (expr.expressions && expr.expressions.length > 0) {
+            return expr.expressions.every(e => isAPICompatible(e, reasons));
+        }
+    }
+    return false;
+}
+function extractAPIFilters(expr) {
+    const filters = {};
+    if (expr.type === 'comparison') {
+        const field = expr.field?.toLowerCase();
+        const operator = expr.operator;
+        const value = expr.value;
+        if (field === 'assignee' && operator === '=') {
+            filters.assignee = value != null ? String(value) : '';
+        }
+        else if (field === 'status' && operator === '=') {
+            filters.status = value != null ? String(value) : '';
+        }
+        else if (field === 'dartboard' && operator === '=') {
+            filters.dartboard = value != null ? String(value) : '';
+        }
+        else if (field === 'priority' && operator === '=') {
+            const numValue = typeof value === 'number' ? value : parseFloat(String(value));
+            filters.priority = isNaN(numValue) ? 0 : numValue;
+        }
+        else if (field === 'tags' && operator === '=') {
+            filters.tags = value != null ? [String(value)] : [];
+        }
+        else if (field === 'due_at') {
+            if (operator === '<' || operator === '<=') {
+                filters.due_before = value != null ? String(value) : '';
+            }
+            else if (operator === '>' || operator === '>=') {
+                filters.due_after = value != null ? String(value) : '';
+            }
+        }
+    }
+    else if (expr.type === 'logical' && expr.operator === 'AND') {
+        const leftFilters = expr.left ? extractAPIFilters(expr.left) : {};
+        const rightFilters = expr.right ? extractAPIFilters(expr.right) : {};
+        Object.assign(filters, leftFilters, rightFilters);
+    }
+    else if (expr.type === 'group') {
+        if (expr.expressions && expr.expressions.length > 0) {
+            return extractAPIFilters(expr.expressions[0]);
+        }
+    }
+    return filters;
+}
+function buildClientSideFilter(expr) {
+    return (task) => {
+        return evaluateExpression(expr, task);
+    };
+}
+function evaluateExpression(expr, task) {
+    if (!task || typeof task !== 'object') {
+        return false;
+    }
+    const taskObj = task;
+    if (expr.type === 'comparison') {
+        const field = expr.field?.toLowerCase();
+        const operator = expr.operator;
+        const value = expr.value;
+        if (!field)
+            return false;
+        const taskValue = taskObj[field];
+        switch (operator) {
+            case '=':
+                return taskValue === value;
+            case '!=':
+                return taskValue !== value;
+            case '>':
+                return typeof taskValue === 'number' && typeof value === 'number' && taskValue > value;
+            case '>=':
+                return typeof taskValue === 'number' && typeof value === 'number' && taskValue >= value;
+            case '<':
+                if (typeof taskValue === 'number' && typeof value === 'number') {
+                    return taskValue < value;
+                }
+                if (typeof taskValue === 'string' && typeof value === 'string') {
+                    return taskValue < value;
+                }
+                return false;
+            case '<=':
+                if (typeof taskValue === 'number' && typeof value === 'number') {
+                    return taskValue <= value;
+                }
+                if (typeof taskValue === 'string' && typeof value === 'string') {
+                    return taskValue <= value;
+                }
+                return false;
+            case 'IN':
+                if (Array.isArray(value)) {
+                    return value.includes(taskValue);
+                }
+                return false;
+            case 'NOT IN':
+                if (Array.isArray(value)) {
+                    return !value.includes(taskValue);
+                }
+                return false;
+            case 'CONTAINS':
+                if (Array.isArray(taskValue) && typeof value === 'string') {
+                    return taskValue.includes(value);
+                }
+                if (typeof taskValue === 'string' && typeof value === 'string') {
+                    return taskValue.includes(value);
+                }
+                return false;
+            case 'LIKE':
+                if (typeof taskValue === 'string' && typeof value === 'string') {
+                    const escaped = value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+                    const pattern = escaped.replace(/%/g, '.*').replace(/_/g, '.');
+                    const regex = new RegExp(`^${pattern}$`, 'i');
+                    return regex.test(taskValue);
+                }
+                return false;
+            case 'IS NULL':
+                if (Array.isArray(taskValue)) {
+                    return taskValue.length === 0;
+                }
+                return taskValue === null || taskValue === undefined;
+            case 'IS NOT NULL':
+                if (Array.isArray(taskValue)) {
+                    return taskValue.length > 0;
+                }
+                return taskValue !== null && taskValue !== undefined;
+            case 'BETWEEN':
+                if (Array.isArray(value) && value.length === 2) {
+                    const [min, max] = value;
+                    if (typeof taskValue === 'number' && typeof min === 'number' && typeof max === 'number') {
+                        return taskValue >= min && taskValue <= max;
+                    }
+                    if (typeof taskValue === 'string' && typeof min === 'string' && typeof max === 'string') {
+                        return taskValue >= min && taskValue <= max;
+                    }
+                }
+                return false;
+            default:
+                return false;
+        }
+    }
+    else if (expr.type === 'logical') {
+        if (expr.operator === 'AND') {
+            const leftResult = expr.left ? evaluateExpression(expr.left, task) : false;
+            const rightResult = expr.right ? evaluateExpression(expr.right, task) : false;
+            return leftResult && rightResult;
+        }
+        else if (expr.operator === 'OR') {
+            const leftResult = expr.left ? evaluateExpression(expr.left, task) : false;
+            const rightResult = expr.right ? evaluateExpression(expr.right, task) : false;
+            return leftResult || rightResult;
+        }
+        else if (expr.operator === 'NOT') {
+            const result = expr.right ? evaluateExpression(expr.right, task) : false;
+            return !result;
+        }
+    }
+    else if (expr.type === 'group') {
+        if (expr.expressions && expr.expressions.length > 0) {
+            return evaluateExpression(expr.expressions[0], task);
+        }
+    }
+    return false;
+}
+export function parseDartQL(input) {
+    try {
+        const tokenizer = new DartQLTokenizer(input);
+        const tokens = tokenizer.tokenize();
+        const lexer = new DartQLLexer(tokens);
+        const result = lexer.analyze();
+        return result;
+    }
+    catch (error) {
+        if (error instanceof DartQLParseError) {
+            return {
+                tokens: [],
+                fields: [],
+                errors: [error.message],
+            };
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=dartql.js.map