Class SortOrderComparator

src/data/helper/dataValueHelper.ts:143–190

}

export class SortOrderComparator {
    private _incomparable: number;
    private _resultLT: -1 | 1;
    /**
     * @param order by default: 'asc'
     * @param incomparable by default: Always on the tail.
     *        That is, if 'asc' => 'max', if 'desc' => 'min'
     *        See the definition of "incomparable" in [SORT_COMPARISON_RULE].
     */
    constructor(order: 'asc' | 'desc', incomparable: 'min' | 'max') {
        const isDesc = order === 'desc';
        this._resultLT = isDesc ? 1 : -1;
        if (incomparable == null) {
            incomparable = isDesc ? 'min' : 'max';
        }
        this._incomparable = incomparable === 'min' ? -Infinity : Infinity;
    }
    // See [SORT_COMPARISON_RULE].
    // Performance sensitive.
    evaluate(lval: unknown, rval: unknown): -1 | 0 | 1 {
        // Most cases is 'number', and typeof maybe 10 times faseter than parseFloat.
        let lvalFloat = isNumber(lval) ? lval : numericToNumber(lval);
        let rvalFloat = isNumber(rval) ? rval : numericToNumber(rval);
        const lvalNotNumeric = isNaN(lvalFloat as number);
        const rvalNotNumeric = isNaN(rvalFloat as number);

        if (lvalNotNumeric) {
            lvalFloat = this._incomparable;
        }
        if (rvalNotNumeric) {
            rvalFloat = this._incomparable;
        }
        if (lvalNotNumeric && rvalNotNumeric) {
            const lvalIsStr = isString(lval);
            const rvalIsStr = isString(rval);
            if (lvalIsStr) {
                lvalFloat = rvalIsStr ? lval as unknown as number : 0;
            }
            if (rvalIsStr) {
                rvalFloat = lvalIsStr ? rval as unknown as number : 0;
            }
        }

        return lvalFloat < rvalFloat ? this._resultLT
            : lvalFloat > rvalFloat ? (-this._resultLT as -1 | 1)
            : 0;
    }
}

class FilterEqualityComparator implements FilterComparator {
    private _isEQ: boolean;