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

import { __assign, __read, __spread } from "tslib";
import { assert } from './util/helper';
import { aggregate } from './aggregate';
import { partition } from './util/partition';
import { oneMoreValue } from './smartMock';
var tuple = function () {
    var args = [];
    for (var _i = 0; _i < arguments.length; _i++) {
        args[_i] = arguments[_i];
    }
    return args;
};
/**
 * @beta
 */
export var AGGREGATION = tuple('sum', 'max', 'min', 'average', 'avg', 'median', 'count', 'distinct', 'countd');
/**
 * @beta
 */
export var CONVERSION = tuple('toString', 'toFloat', 'toInt');
/**
 * @beta
 */
export var FILL = tuple('fillNull', 'removeNull');
export function isFillNullOptionsBySmart(options) {
    return options.type === 'bySmart';
}
export function isFillNullOptionsByAgg(options) {
    return options.type === 'byAgg';
}
export function isFillNullOptionsByValue(options) {
    return options.type === 'byValue';
}
var ACTION_TYPES = { AGGREGATION: AGGREGATION, CONVERSION: CONVERSION, FILL: FILL };
function converse(value, type) {
    if (type === 'toString') {
        return String(value);
    }
    if (type === 'toFloat') {
        return parseFloat(value);
    }
    if (type === 'toInt') {
        return parseInt(value);
    }
    return value; // fail, return origin
}
function fillNull(data, field, fillNullOptions) {
    var result = null;
    if (isFillNullOptionsByValue(fillNullOptions)) {
        result = [];
        data.forEach(function (row) {
            var newRow = __assign({}, row);
            if (!newRow[field]) {
                newRow[field] = fillNullOptions.cfg.value;
            }
            result.push(newRow);
        });
    }
    if (isFillNullOptionsByAgg(fillNullOptions)) {
        result = [];
        var tempAgg_1 = aggregate(data.filter(function (row) { return !!row[field]; }), { as: [field], fields: [field], op: [fillNullOptions.cfg.agg] });
        data.forEach(function (row) {
            var newRow = __assign({}, row);
            if (!newRow[field]) {
                newRow[field] = tempAgg_1[0][field];
            }
            result.push(newRow);
        });
    }
    if (isFillNullOptionsBySmart(fillNullOptions)) {
        result = [];
        var cleanField_1 = data.map(function (row) { return row[field]; }).filter(function (e) { return !!e; });
        data.forEach(function (row) {
            var newRow = __assign({}, row);
            if (!newRow[field]) {
                newRow[field] = oneMoreValue(cleanField_1);
            }
            result.push(newRow);
        });
    }
    return result;
}
function parseSingleSchema(data, schema) {
    var groupBy = schema.groupBy, actions = schema.actions;
    var result = data;
    if (groupBy) {
        var group = partition(data, __spread(groupBy));
        result = Object.values(group).map(function (groupArray) {
            assert(Array.isArray(groupArray) && groupArray.length > 0, "Invalid groupby!");
            var newRow = {};
            groupBy.forEach(function (g) {
                newRow[g] = groupArray[0][g];
            });
            return newRow;
        });
    }
    actions.forEach(function (action) {
        var type = action.type, field = action.field, as = action.as, options = action.options;
        var actionCategory = Object.keys(ACTION_TYPES).find(function (cate) { return ACTION_TYPES[cate].some(function (t) { return t === type; }); });
        var requiredAs = 'new_field';
        if (as) {
            requiredAs = as;
        }
        else if (field) {
            requiredAs = field;
        }
        if (actionCategory === 'AGGREGATION') {
            var aggregateParams = {
                as: [requiredAs],
                op: [type],
            };
            if (field) {
                aggregateParams.fields = [field];
            }
            if (groupBy) {
                aggregateParams.groupBy = groupBy;
            }
            var tempAgg_2 = aggregate(data, aggregateParams);
            result.forEach(function (row, index) {
                row[requiredAs] = tempAgg_2[index][requiredAs];
            });
        }
        if (actionCategory === 'CONVERSION') {
            if (field) {
                var tempCon_1 = data.map(function (row) {
                    var newRow = __assign({}, row);
                    newRow[requiredAs] = converse(row[field], type);
                    return newRow;
                });
                result.forEach(function (row, index) {
                    row[requiredAs] = tempCon_1[index][requiredAs];
                });
            }
        }
        if (actionCategory === 'FILL') {
            if (type === 'removeNull') {
                if (field) {
                    result = result.filter(function (row) { return row[field]; });
                }
            }
            if (type === 'fillNull') {
                if (field && options) {
                    var attempt = fillNull(result, field, options);
                    if (attempt) {
                        result = attempt;
                    }
                }
            }
        }
    });
    return result;
}
/**
 * @beta
 */
export function parse(data, schemas) {
    var result = data;
    var schemaArray = Array.isArray(schemas) ? schemas : [schemas];
    for (var i = 0; i < schemaArray.length; i++) {
        result = parseSingleSchema(result, schemaArray[i]);
    }
    return result;
}