@kodaris/krubble-components 1.0.51 → 1.0.53

package/dist/table/query.js

@@ -0,0 +1,1015 @@
+/** Data-driven operator metadata map */
+export const KR_OPERATORS = {
+    equals: { key: 'equals', type: 'comparison', dataTypes: ['string', 'number', 'date', 'boolean'], label: 'Equals' },
+    n_equals: { key: 'n_equals', type: 'comparison', dataTypes: ['string', 'number', 'date', 'boolean'], label: "Doesn't equal" },
+    contains: { key: 'contains', type: 'comparison', dataTypes: ['string'], label: 'Contains' },
+    n_contains: { key: 'n_contains', type: 'comparison', dataTypes: ['string'], label: "Doesn't contain" },
+    starts_with: { key: 'starts_with', type: 'comparison', dataTypes: ['string'], label: 'Starts with' },
+    ends_with: { key: 'ends_with', type: 'comparison', dataTypes: ['string'], label: 'Ends with' },
+    less_than: { key: 'less_than', type: 'comparison', dataTypes: ['number', 'date'], label: 'Less than' },
+    less_than_equal: { key: 'less_than_equal', type: 'comparison', dataTypes: ['number', 'date'], label: 'Less than or equal' },
+    greater_than: { key: 'greater_than', type: 'comparison', dataTypes: ['number', 'date'], label: 'Greater than' },
+    greater_than_equal: { key: 'greater_than_equal', type: 'comparison', dataTypes: ['number', 'date'], label: 'Greater than or equal' },
+    between: { key: 'between', type: 'range', dataTypes: ['number', 'date'], label: 'Between' },
+    in: { key: 'in', type: 'list', dataTypes: ['string', 'number'], label: 'In' },
+    empty: { key: 'empty', type: 'nil', dataTypes: ['string', 'number', 'date', 'boolean'], label: 'Empty' },
+    n_empty: { key: 'n_empty', type: 'nil', dataTypes: ['string', 'number', 'date', 'boolean'], label: 'Not empty' },
+};
+/** Returns the list of operators available for a given column type */
+export function getOperatorsForType(columnType) {
+    const results = [];
+    for (const op of Object.values(KR_OPERATORS)) {
+        if (op.dataTypes.includes(columnType)) {
+            results.push({
+                key: op.key,
+                label: op.label
+            });
+        }
+    }
+    return results;
+}
+// === Solr Utilities ===
+const SOLR_RESERVED_CHARS = [
+    '"', '+', '-', '&&', '||', '!', '(', ')', '{',
+    '}', '[', ']', '^', '~', '*', '?', ':'
+];
+const SOLR_RESERVED_CHARS_REPLACEMENT = [
+    '\\"', '\\+', '\\-', '\\&\\&', '\\|\\|', '\\!', '\\(', '\\)', '\\{',
+    '\\}', '\\[', '\\]', '\\^', '\\~', '\\*', '\\?', '\\:'
+];
+function escapeRegex(str) {
+    if (typeof str !== 'string') {
+        return str;
+    }
+    return str.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
+}
+/** Converts a value to a Solr term */
+export function termify(value, exact = true) {
+    if (value === true || value === false) {
+        return value.toString();
+    }
+    if (value === null) {
+        return `(*:* NOT *)`;
+    }
+    if (typeof value === 'number') {
+        return value.toString();
+    }
+    if (typeof value === 'string') {
+        SOLR_RESERVED_CHARS.forEach((char, i) => {
+            value = value.replace(new RegExp(`${escapeRegex(char)}`, 'g'), SOLR_RESERVED_CHARS_REPLACEMENT[i]);
+        });
+        if (exact) {
+            return `"${value}"`;
+        }
+        return value.replace(/ /g, `\\ `);
+    }
+    return value;
+}
+/** Converts a Date to a Solr term */
+function termifyDate(value, endOfTheDay = false) {
+    const newTime = new Date(value);
+    newTime.setMinutes(newTime.getMinutes() - newTime.getTimezoneOffset());
+    if (endOfTheDay) {
+        newTime.setUTCHours(23);
+        newTime.setUTCMinutes(59);
+        newTime.setUTCSeconds(59);
+        newTime.setUTCMilliseconds(999);
+    }
+    return newTime.toISOString().replace(/:/g, '\\:');
+}
+/** Creates a Solr date range expression from a Date or range of Dates */
+function createSolrDateRange(value, specificities) {
+    let startDate;
+    let endDate;
+    let startSpecificity;
+    let endSpecificity;
+    if (value && 'start' in value && 'end' in value) {
+        startDate = new Date(value.start);
+        endDate = new Date(value.end);
+        startSpecificity = specificities[0];
+        endSpecificity = specificities[1];
+    }
+    else if (value instanceof Date) {
+        startDate = new Date(value);
+        endDate = new Date(value);
+        startSpecificity = specificities[0];
+        endSpecificity = specificities[0];
+    }
+    else {
+        return '[* TO *]';
+    }
+    if (startSpecificity === 'year') {
+        startDate.setUTCMonth(0, 1);
+        startDate.setUTCHours(0, 0, 0, 0);
+    }
+    else if (startSpecificity === 'month') {
+        startDate.setUTCDate(1);
+        startDate.setUTCHours(0, 0, 0, 0);
+    }
+    else if (startSpecificity === 'day') {
+        startDate.setUTCHours(0, 0, 0, 0);
+    }
+    else if (startSpecificity === 'time') {
+        startDate.setUTCSeconds(0, 0);
+    }
+    if (endSpecificity === 'year') {
+        endDate.setUTCMonth(11, 31);
+        endDate.setUTCHours(23, 59, 59, 999);
+    }
+    else if (endSpecificity === 'month') {
+        endDate.setUTCMonth(endDate.getUTCMonth() + 1);
+        endDate.setUTCDate(0);
+        endDate.setUTCHours(23, 59, 59, 999);
+    }
+    else if (endSpecificity === 'day') {
+        endDate.setUTCHours(23, 59, 59, 999);
+    }
+    else if (endSpecificity === 'time') {
+        endDate.setUTCSeconds(59, 999);
+    }
+    return `[${startDate.toISOString().replace(/:/g, '\\:')} TO ${endDate.toISOString().replace(/:/g, '\\:')}]`;
+}
+/** Creates a DB date range array from a Date or range of Dates, expanding based on specificity */
+function createDbDateRange(value, specificities) {
+    let startDate;
+    let endDate;
+    let startSpecificity;
+    let endSpecificity;
+    if (value && 'start' in value && 'end' in value) {
+        startDate = new Date(value.start);
+        endDate = new Date(value.end);
+        startSpecificity = specificities[0];
+        endSpecificity = specificities[1];
+    }
+    else {
+        startDate = new Date(value);
+        endDate = new Date(value);
+        startSpecificity = specificities[0];
+        endSpecificity = specificities[0];
+    }
+    let start;
+    let end;
+    if (startSpecificity === 'year') {
+        startDate.setUTCMonth(0, 1);
+        startDate.setUTCHours(0, 0, 0, 0);
+        start = startDate;
+    }
+    else if (startSpecificity === 'month') {
+        startDate.setUTCDate(1);
+        startDate.setUTCHours(0, 0, 0, 0);
+        start = startDate;
+    }
+    else if (startSpecificity === 'day') {
+        startDate.setUTCHours(0, 0, 0, 0);
+        start = startDate;
+    }
+    else if (startSpecificity === 'time') {
+        startDate.setUTCSeconds(0, 0);
+        start = startDate;
+    }
+    else {
+        start = startDate;
+    }
+    if (endSpecificity === 'year') {
+        endDate.setUTCMonth(11, 31);
+        endDate.setUTCHours(23, 59, 59, 999);
+        end = endDate;
+    }
+    else if (endSpecificity === 'month') {
+        endDate.setUTCMonth(endDate.getUTCMonth() + 1);
+        endDate.setUTCDate(0);
+        endDate.setUTCHours(23, 59, 59, 999);
+        end = endDate;
+    }
+    else if (endSpecificity === 'day') {
+        endDate.setUTCHours(23, 59, 59, 999);
+        end = endDate;
+    }
+    else if (endSpecificity === 'time') {
+        endDate.setUTCSeconds(59, 999);
+        end = endDate;
+    }
+    else {
+        end = endDate;
+    }
+    return [
+        start.toISOString().replace(/\..+/, '').replace('T', ' '),
+        end.toISOString().replace(/\..+/, '').replace('T', ' '),
+    ];
+}
+/** Determines the date specificity from the text format */
+function getDateSpecificity(input) {
+    input = input.trim();
+    // MM/dd/yy, M/d/yy (2-digit year)
+    if (/^(\d{1,2})\/(\d{1,2})\/(\d{2})$/.test(input)) {
+        return 'day';
+    }
+    // MM/dd/yyyy, M/d/yyyy (4-digit year)
+    if (/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/.test(input)) {
+        return 'day';
+    }
+    // MM/dd/yyyy, t — date with time (4-digit year only)
+    if (/^(\d{1,2})\/(\d{1,2})\/(\d{4}),?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?$/i.test(input)) {
+        return 'time';
+    }
+    // "Month DD, YYYY, time" with optional weekday
+    if (/^(?:[A-Za-z]+,\s+)?([A-Za-z]+)\s+(\d{1,2}),?\s+(\d{4}),?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?$/i.test(input)) {
+        return 'time';
+    }
+    // "Month DD, YYYY" with optional weekday
+    if (/^(?:[A-Za-z]+,\s+)?([A-Za-z]+)\s+(\d{1,2}),?\s+(\d{4})$/.test(input)) {
+        return 'day';
+    }
+    // yy (2-digit year)
+    if (/^(\d{2})$/.test(input)) {
+        return 'year';
+    }
+    // yyyy (4-digit year)
+    if (/^(\d{4})$/.test(input)) {
+        return 'year';
+    }
+    // "MMM yyyy" or "MMMM yyyy" — "Aug 2015", "August 2015"
+    if (/^([A-Za-z]+)\s+(\d{4})$/.test(input)) {
+        return 'month';
+    }
+    return null;
+}
+export class KRQuery {
+    constructor() {
+        this.field = '';
+        this.operator = 'equals';
+        this.value = null;
+        this.kql = '';
+        this.text = '';
+        this.type = '';
+        this.specificity = [];
+    }
+    // --------------------------------------------------------------------------
+    // Public Methods
+    // --------------------------------------------------------------------------
+    /** Parse a KQL text string and populate operator/value/values */
+    setKql(kql) {
+        this.kql = kql.trim();
+        this.text = '';
+        this.specificity = [];
+        this.value = null;
+        if (!this.kql) {
+            if (this.type === 'string') {
+                this.operator = 'contains';
+            }
+            else {
+                this.operator = 'equals';
+            }
+            return;
+        }
+        if (kql.startsWith('=')) {
+            this.operator = 'equals';
+            this.text = kql.substring(1).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('!=')) {
+            this.operator = 'n_equals';
+            this.text = kql.substring(2).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('~') && this.type === 'string') {
+            this.operator = 'contains';
+            this.text = kql.substring(1).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('!~') && this.type === 'string') {
+            this.operator = 'n_contains';
+            this.text = kql.substring(2).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.endsWith('*') && this.type === 'string') {
+            this.operator = 'starts_with';
+            this.text = kql.substring(0, kql.length - 1);
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('*') && this.type === 'string') {
+            this.operator = 'ends_with';
+            this.text = kql.substring(1);
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql === 'EMPTY') {
+            this.operator = 'empty';
+            this.value = null;
+            this.specificity = [];
+        }
+        else if (kql === 'NOT EMPTY') {
+            this.operator = 'n_empty';
+            this.value = null;
+            this.specificity = [];
+        }
+        else if (kql.startsWith('<=')) {
+            this.operator = 'less_than_equal';
+            this.text = kql.substring(2).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('<')) {
+            this.operator = 'less_than';
+            this.text = kql.substring(1).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('>=')) {
+            this.operator = 'greater_than_equal';
+            this.text = kql.substring(2).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('>')) {
+            this.operator = 'greater_than';
+            this.text = kql.substring(1).trim();
+            this.value = this._parse(this.text);
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else if (kql.startsWith('[') && kql.endsWith(']') && kql.indexOf(' TO ') > -1) {
+            this.operator = 'between';
+            const toIndex = kql.indexOf(' TO ');
+            const rawStart = kql.substring(1, toIndex).trim();
+            const rawEnd = kql.substring(toIndex + 4, kql.length - 1).trim();
+            this.text = `${rawStart} - ${rawEnd}`;
+            this.value = {
+                start: this._parse(rawStart),
+                end: this._parse(rawEnd)
+            };
+            this.specificity = [getDateSpecificity(rawStart), getDateSpecificity(rawEnd)];
+        }
+        else if (kql.startsWith('(') && kql.endsWith(')')) {
+            this.operator = 'in';
+            this.text = kql.substring(1, kql.length - 1).trim();
+            this.value = this.text.split(',')
+                .map(v => v.trim())
+                .map(v => this._parse(v));
+            this.specificity = [getDateSpecificity(this.text)];
+        }
+        else {
+            if (this.type === 'date') {
+                this.operator = 'equals';
+                this.text = this.kql;
+                this.value = this._parse(this.text);
+                this.specificity = [getDateSpecificity(this.text)];
+            }
+            else if (this.type === 'boolean') {
+                this.operator = 'equals';
+                this.text = this.kql;
+                this.value = this._parse(this.text);
+                this.specificity = [getDateSpecificity(this.text)];
+            }
+            else if (this.type === 'number') {
+                this.operator = 'equals';
+                this.text = this.kql;
+                this.value = this._parse(this.text);
+                this.specificity = [getDateSpecificity(this.text)];
+            }
+            else {
+                this.operator = 'contains';
+                this.text = kql;
+                this.value = this._parse(this.text);
+                this.specificity = [getDateSpecificity(this.text)];
+            }
+        }
+    }
+    setOperator(operator) {
+        // Clear value/text when switching away from operators
+        // whose values are incompatible with other operators.
+        if (this.operator === 'empty' || this.operator === 'n_empty') {
+            this.value = null;
+            this.text = '';
+        }
+        else if (this.operator === 'between') {
+            this.value = null;
+            this.text = '';
+        }
+        else if (this.operator === 'in') {
+            this.value = [];
+            this.text = '';
+        }
+        this.operator = operator;
+        // Set up initial value/text for the new operator.
+        if (this.operator === 'empty') {
+            this.value = 'EMPTY';
+            this.text = 'EMPTY';
+        }
+        else if (this.operator === 'n_empty') {
+            this.value = 'NOT EMPTY';
+            this.text = 'NOT EMPTY';
+        }
+        else if (this.operator === 'between') {
+            this.value = null;
+            this.text = '';
+        }
+        else if (this.operator === 'in') {
+            this.value = [];
+            this.text = '';
+        }
+        this._buildKql();
+    }
+    setValue(value, specificity) {
+        this.value = value;
+        if (specificity) {
+            this.specificity = [specificity];
+        }
+        else if (value instanceof Date) {
+            this.specificity = ['time'];
+        }
+        else {
+            this.specificity = [];
+        }
+        this._buildText();
+        this._buildKql();
+    }
+    setStart(value, specificity) {
+        if (this.value?.start === undefined) {
+            this.value = { start: null, end: null };
+        }
+        this.value.start = value;
+        if (specificity) {
+            this.specificity[0] = specificity;
+        }
+        else if (value instanceof Date) {
+            this.specificity[0] = 'time';
+        }
+        this._buildText();
+        this._buildKql();
+    }
+    setEnd(value, specificity) {
+        if (this.value?.end === undefined) {
+            this.value = { start: null, end: null };
+        }
+        this.value.end = value;
+        if (specificity) {
+            this.specificity[1] = specificity;
+        }
+        else if (value instanceof Date) {
+            this.specificity[1] = 'time';
+        }
+        this._buildText();
+        this._buildKql();
+    }
+    clear() {
+        if (this.type === 'string') {
+            this.operator = 'contains';
+        }
+        else {
+            this.operator = 'equals';
+        }
+        this.value = null;
+        this.kql = '';
+        this.text = '';
+        this.specificity = [];
+    }
+    isEmpty() {
+        if (this.operator === 'empty' || this.operator === 'n_empty') {
+            return !this.text;
+        }
+        if (this.operator === 'between') {
+            return !this.value?.start && !this.value?.end;
+        }
+        if (this.operator === 'in') {
+            return !this.value?.length;
+        }
+        return this.value === undefined || this.value === null || this.value === '';
+    }
+    /** Returns true if the value array contains the given value. Only applies to 'in' operator. */
+    has(val) {
+        if (this.operator !== 'in' || !Array.isArray(this.value)) {
+            return false;
+        }
+        // Bucket values from Solr arrive as strings ("true"/"false") but
+        // the value array stores actual booleans, so coerce before comparing.
+        if (this.type === 'boolean' && typeof val === 'string') {
+            if (val === 'true') {
+                val = true;
+            }
+            else if (val === 'false') {
+                val = false;
+            }
+        }
+        return this.value.indexOf(val) >= 0;
+    }
+    /** Adds or removes a value from the 'in' list and rebuilds text/kql. */
+    toggle(val) {
+        if (this.operator !== 'in') {
+            this.setOperator('in');
+        }
+        // Bucket values from Solr arrive as strings ("true"/"false") —
+        // coerce to actual booleans so isValid() and toSolrData() work correctly.
+        if (this.type === 'boolean' && typeof val === 'string') {
+            if (val === 'true') {
+                val = true;
+            }
+            else if (val === 'false') {
+                val = false;
+            }
+        }
+        const index = this.value.indexOf(val);
+        if (index >= 0) {
+            this.value.splice(index, 1);
+        }
+        else {
+            this.value.push(val);
+        }
+        this._buildText();
+        this._buildKql();
+    }
+    isValid() {
+        if (!this.kql) {
+            return true;
+        }
+        if (!this.field) {
+            return false;
+        }
+        if (!this.operator) {
+            return false;
+        }
+        if (this.operator === 'empty') {
+            return true;
+        }
+        if (this.operator === 'n_empty') {
+            return true;
+        }
+        // For 'in' operator, valid as long as there's at least one value (including null for empty buckets)
+        if (this.operator === 'in') {
+            return Array.isArray(this.value) && this.value.length > 0;
+        }
+        if (this.type === 'date') {
+            if (this.operator === 'between') {
+                return this.value?.start instanceof Date
+                    && this.value?.end instanceof Date
+                    && !isNaN(this.value.start.getTime())
+                    && !isNaN(this.value.end.getTime());
+            }
+            return this.value instanceof Date && !isNaN(this.value.getTime());
+        }
+        if (this.type === 'number') {
+            if (this.operator === 'between') {
+                return typeof this.value?.start === 'number' && typeof this.value?.end === 'number';
+            }
+            return typeof this.value === 'number';
+        }
+        if (this.type === 'boolean') {
+            return typeof this.value === 'boolean';
+        }
+        return typeof this.value === 'string' && !!this.value.trim().length;
+    }
+    /** Converts this filter to a Solr filter field object, or null if invalid */
+    toSolrData() {
+        const data = {
+            boost: null,
+            fuzzy: null,
+            not: false,
+            name: null,
+            operation: null,
+            tagged: false,
+            value: null
+        };
+        data.name = this.field;
+        switch (this.operator) {
+            case 'equals':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = createSolrDateRange(this.value, this.specificity);
+                }
+                else {
+                    data.operation = 'IS';
+                    data.value = this.value;
+                }
+                break;
+            case 'n_equals':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.not = true;
+                    data.value = createSolrDateRange(this.value, this.specificity);
+                }
+                else {
+                    data.operation = 'IS';
+                    data.not = true;
+                    data.value = this.value;
+                }
+                break;
+            case 'contains':
+                data.operation = 'EXPRESSION';
+                data.value = `*${termify(this.value, false)}*`;
+                break;
+            case 'n_contains':
+                data.operation = 'EXPRESSION';
+                data.not = true;
+                data.value = `*${termify(this.value, false)}*`;
+                break;
+            case 'starts_with':
+                data.operation = 'EXPRESSION';
+                data.value = `${termify(this.value, false)}*`;
+                break;
+            case 'ends_with':
+                data.operation = 'EXPRESSION';
+                data.value = `*${termify(this.value, false)}`;
+                break;
+            case 'empty':
+                data.operation = 'EXPRESSION';
+                data.not = true;
+                data.value = '[* TO *]';
+                break;
+            case 'n_empty':
+                data.operation = 'EXPRESSION';
+                data.value = '[* TO *]';
+                break;
+            case 'less_than':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[* TO ${termifyDate(this.value)}}`;
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[* TO ${termify(this.value, true)}}`;
+                }
+                break;
+            case 'less_than_equal':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[* TO ${termifyDate(this.value, true)}]`;
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[* TO ${termify(this.value, true)}]`;
+                }
+                break;
+            case 'greater_than':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = `{${termifyDate(this.value, true)} TO *]`;
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = `{${termify(this.value, true)} TO *]`;
+                }
+                break;
+            case 'greater_than_equal':
+                if (this.value instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[${termifyDate(this.value)} TO *]`;
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[${termify(this.value, true)} TO *]`;
+                }
+                break;
+            case 'between':
+                if (this.value?.start instanceof Date && this.value?.end instanceof Date) {
+                    data.operation = 'EXPRESSION';
+                    data.value = createSolrDateRange(this.value, this.specificity);
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = `[${this.value.start} TO ${this.value.end}]`;
+                }
+                break;
+            case 'in':
+                if (Array.isArray(this.value) && this.value.length > 0) {
+                    data.operation = 'EXPRESSION';
+                    data.value = `(${this.value.map((v) => termify(v, true)).join(' OR ')})`;
+                }
+                else {
+                    data.operation = 'EXPRESSION';
+                    data.value = termify(this.value, true);
+                }
+                break;
+            default:
+                data.operation = 'EXPRESSION';
+                data.value = termify(this.value, true);
+        }
+        return data;
+    }
+    /** Converts this filter to a DB filter field object, or null if invalid */
+    toDbParams() {
+        const params = {
+            boost: null,
+            fuzzy: null,
+            not: false,
+            name: null,
+            operation: null,
+            tagged: false,
+            value: null,
+            values: null
+        };
+        params.name = this.field;
+        switch (this.operator) {
+            case 'equals':
+                if (this.type === 'date') {
+                    params.operation = 'BETWEEN';
+                    params.values = createDbDateRange(this.value, this.specificity);
+                }
+                else {
+                    params.operation = 'IS';
+                    params.value = this.value;
+                }
+                break;
+            case 'n_equals':
+                if (this.type === 'date') {
+                    params.operation = 'BETWEEN';
+                    params.not = true;
+                    params.values = createDbDateRange(this.value, this.specificity);
+                }
+                else {
+                    params.operation = 'IS';
+                    params.value = this.value;
+                    params.not = true;
+                }
+                break;
+            case 'contains':
+                params.operation = 'CONTAINS';
+                params.value = this.value;
+                break;
+            case 'n_contains':
+                params.operation = 'CONTAINS';
+                params.value = this.value;
+                params.not = true;
+                break;
+            case 'starts_with':
+                params.operation = 'STARTS_WITH';
+                params.value = this.value;
+                break;
+            case 'ends_with':
+                params.operation = 'ENDS_WITH';
+                params.value = this.value;
+                break;
+            case 'empty':
+                params.operation = 'IS_BLANK';
+                break;
+            case 'n_empty':
+                params.operation = 'IS_NOT_BLANK';
+                break;
+            case 'less_than':
+                params.operation = 'LESS_THAN';
+                params.value = this.value;
+                break;
+            case 'less_than_equal':
+                params.operation = 'LESS_THAN_EQUAL';
+                params.value = this.value;
+                break;
+            case 'greater_than':
+                params.operation = 'GREATER_THAN';
+                params.value = this.value;
+                break;
+            case 'greater_than_equal':
+                params.operation = 'GREATER_THAN_EQUAL';
+                params.value = this.value;
+                break;
+            case 'between':
+                params.operation = 'BETWEEN';
+                if (this.type === 'date') {
+                    params.values = createDbDateRange(this.value, this.specificity);
+                }
+                else {
+                    params.values = [this.value.start, this.value.end];
+                }
+                break;
+            case 'in':
+                params.operation = 'IN';
+                params.values = this.value ?? [];
+                break;
+            default:
+                throw Error(`${this.operator} operator not supported by db params.`);
+        }
+        return params;
+    }
+    // --------------------------------------------------------------------------
+    // Private Methods
+    // --------------------------------------------------------------------------
+    _buildText() {
+        if (this.isEmpty()) {
+            this.text = '';
+            return;
+        }
+        if (this.operator === 'between') {
+            this.text = `${this._format(this.value?.start)} - ${this._format(this.value?.end)}`;
+        }
+        else if (this.operator === 'in') {
+            this.text = this.value.map((v) => this._format(v)).join(',');
+        }
+        else {
+            this.text = this._format(this.value);
+        }
+    }
+    _format(value) {
+        if (value instanceof Date && !isNaN(value.getTime())) {
+            const month = String(value.getUTCMonth() + 1).padStart(2, '0');
+            const day = String(value.getUTCDate()).padStart(2, '0');
+            const year = value.getUTCFullYear();
+            return `${month}/${day}/${year}`;
+        }
+        if (typeof value === 'boolean') {
+            return value ? 'Yes' : 'No';
+        }
+        return String(value ?? '');
+    }
+    /** Parse a text value according to this query's type */
+    _parse(text) {
+        if (typeof text === 'undefined' || text === null || text === '') {
+            return null;
+        }
+        if (this.type) {
+            switch (this.type) {
+                case 'boolean': {
+                    const lcInput = text.toString().toLowerCase();
+                    if (text === true) {
+                        return true;
+                    }
+                    if (text === false) {
+                        return false;
+                    }
+                    if (lcInput === 'yes') {
+                        return true;
+                    }
+                    if (lcInput === 'no') {
+                        return false;
+                    }
+                    if (lcInput === '1') {
+                        return true;
+                    }
+                    if (lcInput === '0') {
+                        return false;
+                    }
+                    return null;
+                }
+                case 'date':
+                    return this._parseDate(text);
+                case 'number': {
+                    const num = Number(text.toString().replace(/[$,]+/g, ''));
+                    if (isNaN(num)) {
+                        return null;
+                    }
+                    return num;
+                }
+                default:
+                    return text.toString();
+            }
+        }
+        return text;
+    }
+    /** Parse a date string into a UTC Date */
+    _parseDate(input) {
+        if (typeof input === 'undefined' || input === null || input === '') {
+            return null;
+        }
+        const months = {
+            jan: 0,
+            january: 0,
+            feb: 1,
+            february: 1,
+            mar: 2,
+            march: 2,
+            apr: 3,
+            april: 3,
+            may: 4,
+            jun: 5,
+            june: 5,
+            jul: 6,
+            july: 6,
+            aug: 7,
+            august: 7,
+            sep: 8,
+            september: 8,
+            oct: 9,
+            october: 9,
+            nov: 10,
+            november: 10,
+            dec: 11,
+            december: 11
+        };
+        let m;
+        // MM/dd/yy, M/d/yy (2-digit year)
+        m = input.match(/^(\d{1,2})\/(\d{1,2})\/(\d{2})$/);
+        if (m) {
+            return new Date(Date.UTC(2000 + parseInt(m[3]), parseInt(m[1]) - 1, parseInt(m[2])));
+        }
+        // MM/dd/yyyy, M/d/yyyy (4-digit year)
+        m = input.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+        if (m) {
+            return new Date(Date.UTC(parseInt(m[3]), parseInt(m[1]) - 1, parseInt(m[2])));
+        }
+        // MM/dd/yyyy, t — date with time (4-digit year only, matching NGX)
+        m = input.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4}),?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?$/i);
+        if (m) {
+            let hour = parseInt(m[4]);
+            if (m[6]) {
+                if (m[6].toUpperCase() === 'PM' && hour !== 12) {
+                    hour += 12;
+                }
+                if (m[6].toUpperCase() === 'AM' && hour === 12) {
+                    hour = 0;
+                }
+            }
+            return new Date(Date.UTC(parseInt(m[3]), parseInt(m[1]) - 1, parseInt(m[2]), hour, parseInt(m[5])));
+        }
+        // "Month DD, YYYY, time" with optional weekday
+        // Handles: "Oct 14, 1983, 9:32 AM", "October 14, 1983, 9:32 AM", "Tuesday, October 14, 1983, 9:32 AM"
+        m = input.match(/^(?:[A-Za-z]+,\s+)?([A-Za-z]+)\s+(\d{1,2}),?\s+(\d{4}),?\s+(\d{1,2}):(\d{2})\s*(AM|PM)?$/i);
+        if (m) {
+            const month = months[m[1].toLowerCase()];
+            if (month !== undefined) {
+                let hour = parseInt(m[4]);
+                if (m[6]) {
+                    if (m[6].toUpperCase() === 'PM' && hour !== 12) {
+                        hour += 12;
+                    }
+                    if (m[6].toUpperCase() === 'AM' && hour === 12) {
+                        hour = 0;
+                    }
+                }
+                return new Date(Date.UTC(parseInt(m[3]), month, parseInt(m[2]), hour, parseInt(m[5])));
+            }
+        }
+        // "Month DD, YYYY" with optional weekday
+        // Handles: "Oct 14, 1983", "October 14, 1983", "Tuesday, October 14, 1983"
+        m = input.match(/^(?:[A-Za-z]+,\s+)?([A-Za-z]+)\s+(\d{1,2}),?\s+(\d{4})$/);
+        if (m) {
+            const month = months[m[1].toLowerCase()];
+            if (month !== undefined) {
+                return new Date(Date.UTC(parseInt(m[3]), month, parseInt(m[2])));
+            }
+        }
+        // yy (2-digit year)
+        m = input.match(/^(\d{2})$/);
+        if (m) {
+            return new Date(Date.UTC(2000 + parseInt(m[1]), 0, 1));
+        }
+        // yyyy (4-digit year)
+        m = input.match(/^(\d{4})$/);
+        if (m) {
+            return new Date(Date.UTC(parseInt(m[1]), 0, 1));
+        }
+        // "MMM yyyy" or "MMMM yyyy" — "Aug 2015", "August 2015"
+        m = input.match(/^([A-Za-z]+)\s+(\d{4})$/);
+        if (m) {
+            const month = months[m[1].toLowerCase()];
+            if (month !== undefined) {
+                return new Date(Date.UTC(parseInt(m[2]), month, 1));
+            }
+        }
+        return null;
+    }
+    /** Build a KQL display string from current operator/value state */
+    _buildKql() {
+        if (this.isEmpty()) {
+            this.kql = '';
+            return;
+        }
+        switch (this.operator) {
+            case 'equals':
+                this.kql = `= ${this.text}`;
+                break;
+            case 'n_equals':
+                this.kql = `!= ${this.text}`;
+                break;
+            case 'contains':
+                this.kql = `~ ${this.text}`;
+                break;
+            case 'n_contains':
+                this.kql = `!~ ${this.text}`;
+                break;
+            case 'starts_with':
+                this.kql = `${this.text}*`;
+                break;
+            case 'ends_with':
+                this.kql = `*${this.text}`;
+                break;
+            case 'empty':
+                this.kql = 'EMPTY';
+                break;
+            case 'n_empty':
+                this.kql = 'NOT EMPTY';
+                break;
+            case 'less_than':
+                this.kql = `< ${this.text}`;
+                break;
+            case 'less_than_equal':
+                this.kql = `<= ${this.text}`;
+                break;
+            case 'greater_than':
+                this.kql = `> ${this.text}`;
+                break;
+            case 'greater_than_equal':
+                this.kql = `>= ${this.text}`;
+                break;
+            case 'between':
+                this.kql = `[${this._format(this.value?.start ?? '')} TO ${this._format(this.value?.end ?? '')}]`;
+                break;
+            case 'in':
+                this.kql = `(${this.value.map((v) => this._format(v)).join(',')})`;
+                break;
+            default:
+                throw Error(`Unknown operator ${this.operator}`);
+        }
+    }
+}
+//# sourceMappingURL=query.js.map