@antv/dw-transform/es/dataset.js

import { __read, __spread } from "tslib";
import { typeAll, isInterval } from '@antv/dw-analyzer';
import { AGGREGATION } from './parse';
import { aggregate } from './aggregate';
/**
 * @public
 */
export var rankExtractor = function (siblingGroup) {
    var measures = siblingGroup.datasetInfo.measureTitles;
    var data = siblingGroup.dataset;
    var results = [];
    measures.forEach(function (measure) {
        var measureName = measure;
        var measureColumn = data.map(function (row) { return row[measureName]; });
        var sorted = measureColumn.slice().sort(function (a, b) { return b - a; });
        var ranks = measureColumn.map(function (v) { return sorted.indexOf(v) + 1; });
        results.push(ranks);
    });
    return results;
};
/**
 * @public
 */
export var percentExtractor = function (siblingGroup) {
    var measures = siblingGroup.datasetInfo.measureTitles;
    var data = siblingGroup.dataset;
    var results = [];
    measures.forEach(function (measure) {
        var measureName = measure;
        var measureColumn = data.map(function (row) { return row[measureName]; });
        var sum = measureColumn.reduce(function (a, b) { return a + b; }, 0);
        var percents = measureColumn.map(function (v) { return v / sum; });
        results.push(percents);
    });
    return results;
};
var tuple = function () {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return args;
};
/**
 * @public
 */
export var EXTRACTORS = tuple('rank', 'percent');
/**
 * @public
 */
export var extractors = {
    rank: rankExtractor,
    percent: percentExtractor,
};
/**
 * @public
 */
var Dataset = /** @class */ (function () {
    function Dataset(dataset) {
        this._dataset = dataset;
        this._dimensions = [];
        this._measures = [];
        this._dimensionTitles = [];
        this._measureTitles = [];
        this._calculateDimensionsAndMeasures();
    }
    Object.defineProperty(Dataset.prototype, "dataset", {
        get: function () {
            return this._dataset;
        },
        set: function (dataset) {
            this._dataset = dataset;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Dataset.prototype, "dimensions", {
        get: function () {
            return this._dimensions;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Dataset.prototype, "measures", {
        get: function () {
            return this._measures;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Dataset.prototype, "dimensionTitles", {
        get: function () {
            return this._dimensionTitles;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(Dataset.prototype, "measureTitles", {
        get: function () {
            return this._measureTitles;
        },
        enumerable: false,
        configurable: true
    });
    Dataset.prototype._calculateDimensionsAndMeasures = function () {
        var _this = this;
        var fieldInfos = typeAll(this.dataset);
        fieldInfos.forEach(function (fieldInfo) {
            var fieldColumnInfo = {
                name: fieldInfo.name,
                data: fieldInfo.samples,
                domain: __spread(new Set(fieldInfo.samples)),
            };
            if (isInterval(fieldInfo)) {
                _this._measures.push(fieldColumnInfo);
                _this._measureTitles.push(fieldInfo.name);
            }
            else {
                _this._dimensions.push(fieldColumnInfo);
                _this._dimensionTitles.push(fieldInfo.name);
            }
        });
    };
    Dataset.prototype.subspace = function (defineArray) {
        var _this = this;
        if (defineArray === void 0) { defineArray = this._dimensions.map(function (_) { return '*'; }); }
        if (defineArray.length !== this._dimensions.length) {
            throw new Error('Subspace define array must contain all dimensions.');
        }
        for (var i = 0; i < defineArray.length; i++) {
            if (defineArray[i] !== '*' && !this._dimensions[i].domain.includes(defineArray[i])) {
                console.error(defineArray[i]);
                console.log(this._dimensions[i].domain);
                throw new Error('Subspace define array must mapping to dimension array with * or elements in dimension domain.');
            }
        }
        var subdataset = [];
        this._dataset.forEach(function (row) {
            var isValidRow = true;
            defineArray.forEach(function (defD, index) {
                var titleD = _this._dimensionTitles[index];
                if (defD !== '*' && row[titleD] !== defD) {
                    isValidRow = false;
                }
            });
            if (isValidRow) {
                subdataset.push(row);
            }
        });
        var defineObj = {};
        this._dimensionTitles.forEach(function (d, i) {
            defineObj[d] = defineArray[i];
        });
        return {
            define: defineObj,
            dataset: subdataset,
        };
    };
    Dataset.prototype.siblingGroup = function (subspace, dimension) {
        var _this = this;
        if (!this._dimensionTitles.includes(dimension)) {
            console.log(JSON.stringify(subspace));
            throw new Error("No such dimension: " + dimension + ".");
        }
        var defineSubspace = subspace;
        var defineDimension = dimension;
        var domainD = [];
        var indexD = -1;
        this._dimensions.forEach(function (d, i) {
            if (d.name === defineDimension) {
                domainD = d.domain;
                indexD = i;
            }
        });
        var subspaceList = [];
        domainD.forEach(function (e) {
            var newSubspaceDefineArray = _this._dimensionTitles.map(function (d) { return defineSubspace.define[d]; });
            newSubspaceDefineArray[indexD] = e;
            var newSupspace = _this.subspace(newSubspaceDefineArray);
            subspaceList.push(newSupspace);
        });
        var siblingGroupDataset = [];
        siblingGroupDataset = siblingGroupDataset.concat.apply(siblingGroupDataset, __spread(subspaceList.map(function (subspace) { return subspace.dataset; })));
        return {
            datasetInfo: {
                dimensionTitles: this._dimensionTitles,
                measureTitles: this._measureTitles,
            },
            define: {
                subspace: defineSubspace,
                dimension: defineDimension,
            },
            subspaceList: subspaceList,
            dataset: siblingGroupDataset,
        };
    };
    Dataset.prototype.allSubspaceDataset = function (options) {
        var _this = this;
        var MAX_DEPTH = 3;
        var dimensions = (options && options.dimensions) || this._dimensionTitles;
        var measures = (options && options.measures) || this._measureTitles;
        var aggregations = (options && options.aggregations) || AGGREGATION;
        var extractors = (options && options.extractors) || EXTRACTORS;
        var depth = options && options.depth && options.depth < MAX_DEPTH ? options.depth : MAX_DEPTH;
        // traverse siblingGroups - by combinations of (subspaces & dimensions)
        var defineArray = dimensions.map(function (_) { return '*'; });
        var allSiblingGroups = dimensions.map(function (d) { return _this.siblingGroup(_this.subspace(defineArray), d); });
        // traverse subspaceDatasets - by combinations of (siblingGroups & aggs & measures & extractors & depth)
        var allSubspaceDatasets = [];
        allSiblingGroups.forEach(function (sg) {
            measures.forEach(function (measure) {
                aggregations.forEach(function (agg) {
                    var possibleExtractorPairs = [];
                    extractors.forEach(function (extractor) {
                        dimensions.forEach(function (dimension) {
                            possibleExtractorPairs.push({ extractor: extractor, dimension: dimension });
                        });
                    });
                    var extractorPairs = [];
                    for (var x = 0; x < possibleExtractorPairs.length; x++) {
                        for (var y = 0; y < possibleExtractorPairs.length; y++) {
                            extractorPairs = [possibleExtractorPairs[x], possibleExtractorPairs[y]];
                        }
                    }
                    // remove duplicates
                    var resultsDiffDepth = [];
                    for (var i = 0; i < depth; i++) {
                        var subDataset = compositeExtractor(sg, { agg: agg, measure: measure }, extractorPairs, i);
                        var hasDuplication = false;
                        for (var j = 0; j < resultsDiffDepth.length; j++) {
                            if (Object.keys(resultsDiffDepth[j][0])
                                .sort()
                                .join(',') ===
                                Object.keys(subDataset[0])
                                    .sort()
                                    .join(',')) {
                                hasDuplication = true;
                                break;
                            }
                        }
                        if (!hasDuplication) {
                            resultsDiffDepth.push(subDataset);
                        }
                    }
                    allSubspaceDatasets = allSubspaceDatasets.concat(resultsDiffDepth);
                });
            });
        });
        return allSubspaceDatasets;
    };
    return Dataset;
}());
export { Dataset };
/**
 * @public
 */
export function compositeExtractor(siblingGroup, aggPair, extractorPairs, depth) {
    if (extractorPairs === void 0) { extractorPairs = []; }
    if (depth === void 0) { depth = extractorPairs.length + 1; }
    var result = [];
    var define = siblingGroup.define, datasetInfo = siblingGroup.datasetInfo;
    var defineDimension = define.dimension, defineSubspace = define.subspace;
    var dimensionTitles = datasetInfo.dimensionTitles;
    // first extractor is aggregation
    var agg = aggPair.agg, measure = aggPair.measure;
    var aggedDataset = siblingGroup.dataset.map(function (row) {
        var newRow = [];
        dimensionTitles.forEach(function (d) {
            if (defineSubspace.define[d] !== '*' || d === defineDimension) {
                newRow[d] = row[d];
            }
        });
        newRow[measure] = row[measure];
        return newRow;
    });
    var data1 = aggregate(aggedDataset, {
        groupBy: defineDimension,
        fields: [measure],
        as: [measure],
        op: [agg],
    });
    // rename
    result = data1.map(function (row) {
        var newRow = {};
        Object.keys(row)
            .filter(function (k) { return k !== measure; })
            .forEach(function (k) {
            newRow[k] = row[k];
        });
        newRow[measure + "_" + agg] = row[measure];
        return newRow;
    });
    // then, t-1 round of extracting
    var t = depth < 1 ? 1 : depth;
    t = t > 1 + extractorPairs.length ? 1 + extractorPairs.length : t;
    var _loop_1 = function (i) {
        // each round of extracting
        var tempDataset = new Dataset(result);
        var _a = extractorPairs[i], extractorType = _a.extractor, extractByDimension = _a.dimension;
        if (tempDataset.dimensionTitles.includes(extractByDimension)) {
            var extractor = extractors[extractorType];
            var rColumn_1 = extractor(tempDataset.siblingGroup(tempDataset.subspace(), extractByDimension))[0];
            var extractedResult_1 = [];
            var newMeasureName_1 = tempDataset.measureTitles[0] + "_" + extractorType;
            result.forEach(function (row, index) {
                var newRow = {};
                tempDataset.dimensionTitles.forEach(function (d) {
                    newRow[d] = row[d];
                });
                newRow[newMeasureName_1] = rColumn_1[index];
                extractedResult_1.push(newRow);
            });
            result = extractedResult_1;
        }
    };
    for (var i = 0; i < t - 1; i++) {
        _loop_1(i);
    }
    return result;
}