@visactor/vtable/es/ts-types/dataset/aggregation.js

canvas table width high performance

import { isValid, precisionAdd, precisionSub } from "@visactor/vutils";

import { AggregationType, SortType } from "..";

export const registeredAggregators = {};

export class Aggregator {
    constructor(config) {
        var _a;
        this.isAggregator = !0, this.isRecord = !0, this.records = [], this.children = [], 
        this.key = config.key, this.field = config.field, this.formatFun = config.formatFun, 
        this.isRecord = null !== (_a = config.isRecord) && void 0 !== _a ? _a : this.isRecord;
    }
    clearCacheValue() {
        this._formatedValue = void 0;
    }
    formatValue(col, row, table) {
        return this._formatedValue || (this.formatFun ? this._formatedValue = this.formatFun(this.value(), col, row, table) : this._formatedValue = this.value()), 
        this._formatedValue;
    }
    reset() {
        this.records = [], this.changedValue = void 0, this.children = [], this.clearCacheValue();
    }
}

export class RecordAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.RECORD, this.isRecord = !0;
    }
    push(record) {
        record && this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator && this.children && this.children.push(record), this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record)))), 
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.clearCacheValue());
    }
    value() {
        var _a;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : this.records;
    }
    reset() {
        this.children = [], this.changedValue = void 0, this.records = [];
    }
    recalculate() {}
}

export class NoneAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.NONE, this.isRecord = !0;
    }
    push(record) {
        record && (this.isRecord && (this.records = [ record ]), record.isAggregator && this.children && (this.children = [ record ]), 
        this.field && (this.fieldValue = record[this.field])), this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record))), 
        this.field && this.records.length && (this.fieldValue = this.records[this.records.length - 1][this.field])), 
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.field && this.records.length && (this.fieldValue = this.records[this.records.length - 1][this.field]), 
        this.clearCacheValue());
    }
    value() {
        var _a;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : this.fieldValue;
    }
    reset() {
        this.children = [], this.changedValue = void 0, this.records = [], this.fieldValue = void 0;
    }
    recalculate() {}
}

export class CustomAggregator extends Aggregator {
    constructor(config) {
        super(config), this.type = AggregationType.CUSTOM, this.isRecord = !0, this.values = [], 
        this.aggregationFun = config.aggregationFun;
    }
    push(record) {
        record && (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator && this.children && this.children.push(record), this.field && this.values.push(record[this.field])), 
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.field && this.records.length && (this.values = this.records.map((item => item[this.field]))), 
        this.clearCacheValue());
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record))), 
        this.field && this.records.length && (this.values = this.records.map((item => item[this.field])))), 
        this.clearCacheValue();
    }
    value() {
        var _a, _b;
        return this.fieldValue || (this.fieldValue = null === (_a = this.aggregationFun) || void 0 === _a ? void 0 : _a.call(this, this.values, this.records, this.field)), 
        null !== (_b = this.changedValue) && void 0 !== _b ? _b : this.fieldValue;
    }
    reset() {
        this.records = [], this.children = [], this.changedValue = void 0, this.fieldValue = void 0;
    }
    recalculate() {
        this.fieldValue = void 0, this._formatedValue = void 0;
    }
}

export class RecalculateAggregator extends Aggregator {
    constructor(config) {
        super(config), this.type = AggregationType.RECALCULATE, this.isRecord = !0, this.calculateFun = config.calculateFun, 
        this.dependAggregators = config.dependAggregators, this.dependIndicatorKeys = config.dependIndicatorKeys;
    }
    push(record) {
        record && this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        this.children && record.isAggregator && this.children.push(record), this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record)))), 
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.clearCacheValue());
    }
    value() {
        var _a, _b;
        if (!this.fieldValue) {
            const aggregatorValue = _getDependAggregatorValues(this.dependAggregators, this.dependIndicatorKeys);
            this.fieldValue = null === (_a = this.calculateFun) || void 0 === _a ? void 0 : _a.call(this, aggregatorValue, this.records, this.field);
        }
        return null !== (_b = this.changedValue) && void 0 !== _b ? _b : this.fieldValue;
    }
    reset() {
        this.records = [], this.children = [], this.changedValue = void 0, this.fieldValue = void 0;
    }
    recalculate() {}
}

export class SumAggregator extends Aggregator {
    constructor(config) {
        var _a;
        super(config), this.type = AggregationType.SUM, this.sum = 0, this.positiveSum = 0, 
        this.nagetiveSum = 0, this.needSplitPositiveAndNegativeForSum = !1, this.needSplitPositiveAndNegativeForSum = null !== (_a = config.needSplitPositiveAndNegative) && void 0 !== _a && _a;
    }
    push(record) {
        if (record) if (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator && this.children) {
            this.children.push(record);
            const value = record.value();
            this.sum = precisionAdd(this.sum, null != value ? value : 0), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionAdd(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, value)));
        } else if (this.field && !isNaN(parseFloat(record[this.field]))) {
            const value = parseFloat(record[this.field]);
            this.sum = precisionAdd(this.sum, value), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionAdd(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, value)));
        }
        this.clearCacheValue();
    }
    deleteRecord(record) {
        if (record) {
            if (this.isRecord && this.records) {
                const index = this.records.indexOf(record);
                -1 !== index && this.records.splice(index, 1);
            }
            if (record.isAggregator && this.children) {
                const index = this.children.indexOf(record);
                -1 !== index && this.children.splice(index, 1);
                const value = record.value();
                this.sum = precisionSub(this.sum, null != value ? value : 0), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionSub(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionSub(this.nagetiveSum, value)));
            } else if (this.field && !isNaN(parseFloat(record[this.field]))) {
                const value = parseFloat(record[this.field]);
                this.sum = precisionSub(this.sum, value), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionSub(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionSub(this.nagetiveSum, value)));
            }
        }
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        if (oldRecord && newRecord) {
            if (this.isRecord && this.records) {
                const index = this.records.indexOf(oldRecord);
                -1 !== index && (this.records[index] = newRecord);
            }
            if (oldRecord.isAggregator && this.children) {
                const oldValue = oldRecord.value(), index = this.children.indexOf(oldRecord);
                -1 !== index && (this.children[index] = newRecord);
                const newValue = newRecord.value();
                this.sum = precisionAdd(this.sum, precisionSub(newValue, oldValue)), this.needSplitPositiveAndNegativeForSum && (oldValue > 0 ? this.positiveSum = precisionSub(this.positiveSum, oldValue) : oldValue < 0 && (this.nagetiveSum = precisionSub(this.nagetiveSum, oldValue)), 
                newValue > 0 ? this.positiveSum = precisionAdd(this.positiveSum, newValue) : newValue < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, newValue)));
            } else if (this.field && !isNaN(parseFloat(oldRecord[this.field]))) {
                const oldValue = parseFloat(oldRecord[this.field]), newValue = parseFloat(newRecord[this.field]);
                this.sum = precisionAdd(this.sum, precisionSub(newValue, oldValue)), this.needSplitPositiveAndNegativeForSum && (oldValue > 0 ? this.positiveSum = precisionSub(this.positiveSum, oldValue) : oldValue < 0 && (this.nagetiveSum = precisionSub(this.nagetiveSum, oldValue)), 
                newValue > 0 ? this.positiveSum = precisionAdd(this.positiveSum, newValue) : newValue < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, newValue)));
            }
            this.clearCacheValue();
        }
    }
    value() {
        var _a;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : this.records && this.records.length >= 1 || !1 === this.isRecord ? this.sum : void 0;
    }
    positiveValue() {
        return this.positiveSum;
    }
    negativeValue() {
        return this.nagetiveSum;
    }
    reset() {
        super.reset(), this.records = [], this.sum = 0;
    }
    recalculate() {
        if (this.sum = 0, this._formatedValue = void 0, this.children && this.children.length > 0) for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child.isAggregator) {
                const value = child.value();
                this.sum = precisionAdd(this.sum, null != value ? value : 0), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionAdd(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, value)));
            }
        } else if (this.records) for (let i = 0; i < this.records.length; i++) {
            const record = this.records[i];
            if (record.isAggregator) {
                const value = record.value();
                this.sum = precisionAdd(this.sum, null != value ? value : 0), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionAdd(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, value)));
            } else if (this.field && !isNaN(parseFloat(record[this.field]))) {
                const value = parseFloat(record[this.field]);
                this.sum = precisionAdd(this.sum, value), this.needSplitPositiveAndNegativeForSum && (value > 0 ? this.positiveSum = precisionAdd(this.positiveSum, value) : value < 0 && (this.nagetiveSum = precisionAdd(this.nagetiveSum, value)));
            }
        }
    }
}

export class CountAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.COUNT, this.count = 0;
    }
    push(record) {
        record && (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator ? (this.children && this.children.push(record), this.count += record.value()) : this.count++), 
        this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator ? (this.children && (this.children = this.children.filter((item => item !== record))), 
        this.count -= record.value()) : this.count--), this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && (this.count += newRecord.value() - oldRecord.value()), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))));
    }
    value() {
        var _a;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : this.count;
    }
    reset() {
        this.changedValue = void 0, this.children = [], this.records = [], this.count = 0;
    }
    recalculate() {
        if (this.count = 0, this._formatedValue = void 0, this.children && this.children.length > 0) for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child.isAggregator) {
                const value = child.value();
                this.count += null != value ? value : 0;
            } else this.count++;
        } else if (this.records) for (let i = 0; i < this.records.length; i++) {
            const record = this.records[i];
            record.isAggregator ? this.count += record.value() : this.count++;
        }
    }
}

export class AvgAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.AVG, this.sum = 0, this.count = 0;
    }
    push(record) {
        record && (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator && record.type === AggregationType.AVG ? (this.children && this.children.push(record), 
        this.sum = precisionAdd(this.sum, record.sum), this.count += record.count) : this.field && !isNaN(parseFloat(record[this.field])) && (this.sum = precisionAdd(this.sum, parseFloat(record[this.field])), 
        this.count++)), this.clearCacheValue();
    }
    deleteRecord(record) {
        if (record) {
            if (this.isRecord && this.records) {
                const index = this.records.indexOf(record);
                -1 !== index && this.records.splice(index, 1);
            }
            if (record.isAggregator && record.type === AggregationType.AVG) {
                if (this.children) {
                    const index = this.children.indexOf(record);
                    -1 !== index && this.children.splice(index, 1);
                }
                this.sum = precisionSub(this.sum, record.sum), this.count -= record.count;
            } else this.field && !isNaN(parseFloat(record[this.field])) && (this.sum = precisionSub(this.sum, parseFloat(record[this.field])), 
            this.count--);
        }
        this.clearCacheValue();
    }
    updateRecord(oldRecord, newRecord) {
        if (oldRecord && newRecord) {
            if (this.isRecord && this.records) {
                const index = this.records.indexOf(oldRecord);
                -1 !== index && (this.records[index] = newRecord);
            }
            if (oldRecord.isAggregator && oldRecord.type === AggregationType.AVG) {
                if (this.children && newRecord.isAggregator) {
                    const index = this.children.indexOf(oldRecord);
                    -1 !== index && (this.children[index] = newRecord);
                }
                this.sum = precisionAdd(this.sum, precisionSub(newRecord.sum, oldRecord.sum)), this.count += newRecord.count - oldRecord.count;
            } else this.field && !isNaN(parseFloat(oldRecord[this.field])) && (this.sum = precisionAdd(this.sum, precisionSub(parseFloat(newRecord[this.field]), parseFloat(oldRecord[this.field]))));
            this.clearCacheValue();
        }
    }
    value() {
        var _a;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : this.records && this.records.length >= 1 || !1 === this.isRecord && this.count > 0 ? this.sum / this.count : void 0;
    }
    reset() {
        this.changedValue = void 0, this.children = [], this.records = [], this.sum = 0, 
        this.count = 0;
    }
    recalculate() {
        if (this.sum = 0, this.count = 0, this._formatedValue = void 0, this.children && this.children.length > 0) for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child.isAggregator && child.type === AggregationType.AVG) {
                const childValue = child.value();
                this.sum = precisionAdd(this.sum, childValue * child.count), this.count += child.count;
            }
        } else if (this.records) for (let i = 0; i < this.records.length; i++) {
            const record = this.records[i];
            record.isAggregator && record.type === AggregationType.AVG ? (this.sum = precisionAdd(this.sum, record.sum), 
            this.count += record.count) : this.field && !isNaN(parseFloat(record[this.field])) && (this.sum = precisionAdd(this.sum, parseFloat(record[this.field])), 
            this.count++);
        }
    }
}

export class MaxAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.MAX, this.max = Number.MIN_SAFE_INTEGER;
    }
    push(record) {
        record && (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator ? (this.children && this.children.push(record), this.max = record.max > this.max ? record.max : this.max) : "number" == typeof record ? this.max = record > this.max ? record : this.max : this.field && "number" == typeof record[this.field] ? this.max = record[this.field] > this.max ? record[this.field] : this.max : this.field && !isNaN(record[this.field]) && (this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max)), 
        this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record))), 
        this.recalculate());
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.recalculate());
    }
    value() {
        var _a, _b;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : (null === (_b = this.records) || void 0 === _b ? void 0 : _b.length) >= 1 ? this.max : void 0;
    }
    reset() {
        this.records = [], this.changedValue = void 0, this.children = [], this.max = Number.MIN_SAFE_INTEGER;
    }
    recalculate() {
        if (this.max = Number.MIN_SAFE_INTEGER, this._formatedValue = void 0, this.children && this.children.length > 0) for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child.isAggregator) {
                const childValue = child.value();
                this.max = Math.max(this.max, childValue);
            }
        } else if (this.records) for (let i = 0; i < this.records.length; i++) {
            const record = this.records[i];
            record.isAggregator ? this.max = record.max > this.max ? record.max : this.max : "number" == typeof record ? this.max = record > this.max ? record : this.max : this.field && "number" == typeof record[this.field] ? this.max = record[this.field] > this.max ? record[this.field] : this.max : this.field && !isNaN(record[this.field]) && (this.max = parseFloat(record[this.field]) > this.max ? parseFloat(record[this.field]) : this.max);
        }
    }
}

export class MinAggregator extends Aggregator {
    constructor() {
        super(...arguments), this.type = AggregationType.MIN, this.min = Number.MAX_SAFE_INTEGER;
    }
    push(record) {
        record && (this.isRecord && this.records && (record.isAggregator ? this.records.push(...record.records) : this.records.push(record)), 
        record.isAggregator ? (this.children && this.children.push(record), this.min = record.min < this.min ? record.min : this.min) : "number" == typeof record ? this.min = record < this.min ? record : this.min : this.field && "number" == typeof record[this.field] ? this.min = record[this.field] < this.min ? record[this.field] : this.min : this.field && !isNaN(record[this.field]) && (this.min = parseFloat(record[this.field]) < this.min ? parseFloat(record[this.field]) : this.min)), 
        this.clearCacheValue();
    }
    deleteRecord(record) {
        record && (this.isRecord && this.records && (this.records = this.records.filter((item => item !== record))), 
        record.isAggregator && this.children && (this.children = this.children.filter((item => item !== record))), 
        this.recalculate());
    }
    updateRecord(oldRecord, newRecord) {
        oldRecord && newRecord && (this.isRecord && this.records && (this.records = this.records.map((item => item === oldRecord ? newRecord : item))), 
        oldRecord.isAggregator && newRecord.isAggregator && this.children && (this.children = this.children.map((item => item === oldRecord ? newRecord : item))), 
        this.recalculate());
    }
    value() {
        var _a, _b;
        return null !== (_a = this.changedValue) && void 0 !== _a ? _a : (null === (_b = this.records) || void 0 === _b ? void 0 : _b.length) >= 1 ? this.min : void 0;
    }
    reset() {
        this.records = [], this.changedValue = void 0, this.children = [], this.min = Number.MAX_SAFE_INTEGER;
    }
    recalculate() {
        if (this.min = Number.MAX_SAFE_INTEGER, this._formatedValue = void 0, this.children && this.children.length > 0) for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child.isAggregator) {
                const childValue = child.value();
                this.min = Math.min(this.min, childValue);
            }
        } else if (this.records) for (let i = 0; i < this.records.length; i++) {
            const record = this.records[i];
            record.isAggregator ? this.min = record.min < this.min ? record.min : this.min : "number" == typeof record ? this.min = record < this.min ? record : this.min : this.field && "number" == typeof record[this.field] ? this.min = record[this.field] < this.min ? record[this.field] : this.min : this.field && !isNaN(record[this.field]) && (this.min = parseFloat(record[this.field]) < this.min ? parseFloat(record[this.field]) : this.min);
        }
    }
}

export function indicatorSort(a, b) {
    return a && b ? a.toString().localeCompare(b.toString(), "zh") : a ? 1 : -1;
}

export function typeSort(a, b, sortType) {
    if (sortType === SortType.NORMAL || sortType === SortType.normal) return 0;
    const factor = sortType === SortType.DESC || sortType === SortType.desc ? -1 : 1;
    return a && b ? a.toString().localeCompare(b.toString(), "zh") * factor : a ? 1 * factor : -1 * factor;
}

export function naturalSort(as, bs, sortType) {
    if (sortType === SortType.NORMAL || sortType === SortType.normal) return 0;
    const rx = /(\d+)|(\D+)/g, rd = /\d/, rz = /^0/;
    let a, a1, b, b1, nas = 0, nbs = 0;
    const factor = sortType === SortType.DESC || sortType === SortType.desc ? -1 : 1;
    if (null !== bs && null === as) return -1 * factor;
    if (null !== as && null === bs) return 1 * factor;
    if ("number" == typeof as && isNaN(as)) return -1 * factor;
    if ("number" == typeof bs && isNaN(bs)) return 1 * factor;
    if (nas = +as, nbs = +bs, nas < nbs) return -1 * factor;
    if (nas > nbs) return 1 * factor;
    if ("number" == typeof as && "number" != typeof bs) return -1 * factor;
    if ("number" == typeof bs && "number" != typeof as) return 1 * factor;
    if ("number" == typeof as && "number" == typeof bs) return 0;
    if (isNaN(nbs) && !isNaN(nas)) return -1 * factor;
    if (isNaN(nas) && !isNaN(nbs)) return 1 * factor;
    if (a = String(as), b = String(bs), a === b) return 0;
    if (!rd.test(a) || !rd.test(b)) return (a > b ? 1 : -1) * factor;
    for (a = a.match(rx), b = b.match(rx); a.length && b.length; ) if (a1 = a.shift(), 
    b1 = b.shift(), a1 !== b1) return rd.test(a1) && rd.test(b1) ? (a1.replace(rz, ".0") - b1.replace(rz, ".0")) * factor : (a1 > b1 ? 1 : -1) * factor;
    return (a.length - b.length) * factor;
}

export function sortBy(order) {
    let x;
    const mapping = {}, lowercase_mapping = {};
    for (let i = 0; i < order.length; i++) x = order[i], mapping[x] = i, "string" == typeof x && (lowercase_mapping[x.toLowerCase()] = i);
    return function(a, b, sortType) {
        if (sortType === SortType.NORMAL || sortType === SortType.normal) return 0;
        const factor = sortType === SortType.DESC || sortType === SortType.desc ? -1 : 1;
        let comparison;
        return null !== mapping[a] && void 0 !== mapping[a] && null !== mapping[b] && void 0 !== mapping[b] ? comparison = mapping[a] - mapping[b] : null !== mapping[a] && void 0 !== mapping[a] ? comparison = -1 : null !== mapping[b] && void 0 !== mapping[b] ? comparison = 1 : null !== lowercase_mapping[a] && void 0 !== mapping[a] && null !== lowercase_mapping[b] && void 0 !== mapping[b] ? comparison = lowercase_mapping[a] - lowercase_mapping[b] : null === lowercase_mapping[a] || void 0 === mapping[a] || null === lowercase_mapping[b] || void 0 === mapping[b] ? comparison = 0 : null !== lowercase_mapping[a] && void 0 !== mapping[a] ? comparison = -1 : null !== lowercase_mapping[b] && void 0 !== mapping[b] && (comparison = 1), 
        isValid(comparison) ? comparison * factor : naturalSort(a, b, sortType);
    };
}

function _getDependAggregatorValues(aggregators, dependIndicatorKeys) {
    const dependAggregatorValues = {};
    for (let m = 0; m < (null == dependIndicatorKeys ? void 0 : dependIndicatorKeys.length); m++) {
        const aggrator = aggregators.find((aggrator => (null == aggrator ? void 0 : aggrator.key) === dependIndicatorKeys[m]));
        aggrator && (dependAggregatorValues[aggrator.key] = null == aggrator ? void 0 : aggrator.value());
    }
    return dependAggregatorValues;
}
//# sourceMappingURL=aggregation.js.map