@formant/ava 3.4.1-formant

package/esm/advisor/ruler/rules/nominal-enum-combinatorial.js

@@ -0,0 +1,54 @@
+import { hasSubset } from '../../utils';
+import { compare } from '../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = [
+    'bar_chart',
+    'column_chart',
+    'grouped_bar_chart',
+    'grouped_column_chart',
+    'stacked_bar_chart',
+    'stacked_column_chart',
+];
+function getNominalFields(dataProps) {
+    return dataProps.filter(function (field) { return hasSubset(field.levelOfMeasurements, ['Nominal']); });
+}
+export var nominalEnumCombinatorial = {
+    id: 'nominal-enum-combinatorial',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Single (Basic) and Multi (Stacked, Grouped,...) charts should be optimized recommended by nominal enums combinatorial numbers.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType, dataProps = _a.dataProps;
+        return (applyChartTypes.includes(chartType) && getNominalFields(dataProps).length >= 2);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps, chartType = args.chartType;
+        if (dataProps) {
+            var nominalFields = getNominalFields(dataProps);
+            if (nominalFields.length >= 2) {
+                var sortedNominals = nominalFields.sort(compare);
+                var f1 = sortedNominals[0];
+                var f2 = sortedNominals[1];
+                if (f1.distinct === f1.count) {
+                    if (['bar_chart', 'column_chart'].includes(chartType)) {
+                        result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+                    }
+                }
+                if (f1.count && f1.distinct && f2.distinct && f1.count > f1.distinct) {
+                    var typeOptions = [
+                        'grouped_bar_chart',
+                        'grouped_column_chart',
+                        'stacked_bar_chart',
+                        'stacked_column_chart',
+                    ];
+                    if (typeOptions.includes(chartType)) {
+                        result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+                    }
+                }
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/purpose-check.js

@@ -0,0 +1,27 @@
+export var purposeCheck = {
+    id: 'purpose-check',
+    type: 'HARD',
+    docs: {
+        lintText: 'Choose chart types that satisfy the purpose, if purpose is defined.',
+    },
+    trigger: function () {
+        return true;
+    },
+    validator: function (args) {
+        var result = 0;
+        var chartType = args.chartType, purpose = args.purpose, chartWIKI = args.chartWIKI;
+        // if purpose is not defined
+        if (!purpose) {
+            result = 1;
+            return result;
+        }
+        if (chartType && chartWIKI[chartType] && purpose) {
+            var purp = chartWIKI[chartType].purpose || '';
+            if (purp.includes(purpose)) {
+                result = 1;
+                return result;
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/series-qty-limit.js

@@ -0,0 +1,34 @@
+import { hasSubset } from '../../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = ['pie_chart', 'donut_chart', 'radar_chart', 'rose_chart'];
+export var seriesQtyLimit = {
+    id: 'series-qty-limit',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Some charts should has at most N values for the series.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps, chartType = args.chartType;
+        var limit = args.limit;
+        if (!Number.isInteger(limit) || limit <= 0) {
+            limit = 6;
+            if (chartType === 'pie_chart' || chartType === 'donut_chart' || chartType === 'rose_chart')
+                limit = 6;
+            if (chartType === 'radar_chart')
+                limit = 8;
+        }
+        if (dataProps) {
+            var field4Series = dataProps.find(function (field) { return hasSubset(field.levelOfMeasurements, ['Nominal']); });
+            var seriesQty = field4Series && field4Series.count ? field4Series.count : 0;
+            if (seriesQty >= 2 && seriesQty <= limit) {
+                result = MAX_SOFT_RULE_COEFFICIENT * 0.5 + 2 / seriesQty;
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/x-axis-line-fading.js

@@ -0,0 +1,41 @@
+import { getSpecWithEncodeType } from '../../utils/inferDataType';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = ['line_chart'];
+export var xAxisLineFading = {
+    id: 'x-axis-line-fading',
+    type: 'DESIGN',
+    docs: {
+        // FIXME formal description
+        lintText: 'Adjust axis to make it prettier',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    optimizer: function (dataProps, chartSpec) {
+        var _a;
+        var specWithEncodeType = getSpecWithEncodeType(chartSpec);
+        var encode = specWithEncodeType.encode;
+        if (encode && ((_a = encode.y) === null || _a === void 0 ? void 0 : _a.type) === 'quantitative') {
+            var fieldInfo = dataProps.find(function (item) { var _a; return item.name === ((_a = encode.y) === null || _a === void 0 ? void 0 : _a.field); });
+            if (fieldInfo) {
+                var range = fieldInfo.maximum - fieldInfo.minimum;
+                if (fieldInfo.minimum && fieldInfo.maximum && range < (fieldInfo.maximum * 2) / 3) {
+                    var yScaleMin = Math.floor(fieldInfo.minimum - range / (MAX_SOFT_RULE_COEFFICIENT * 0.5));
+                    return {
+                        axis: {
+                            x: { tick: false },
+                        },
+                        scale: {
+                            y: {
+                                domainMin: yScaleMin > 0 ? yScaleMin : 0,
+                            },
+                        },
+                        clip: true,
+                    };
+                }
+            }
+        }
+        return {};
+    },
+};

package/esm/advisor/ruler/types.js

@@ -0,0 +1 @@
+export {};

package/esm/advisor/ruler/utils.js

@@ -0,0 +1,54 @@
+import { __assign } from "tslib";
+import { intersects } from '../utils';
+import { DEFAULT_RULE_WEIGHTS } from '../constants';
+export function compare(f1, f2) {
+    if (f1.distinct < f2.distinct) {
+        return 1;
+    }
+    if (f1.distinct > f2.distinct) {
+        return -1;
+    }
+    return 0;
+}
+export function verifyDataProps(dataPre, dataProps) {
+    var fieldsLOMs = dataProps.map(function (info) {
+        return info.levelOfMeasurements;
+    });
+    if (fieldsLOMs) {
+        var lomCount_1 = 0;
+        fieldsLOMs.forEach(function (fieldLOM) {
+            if (fieldLOM && intersects(fieldLOM, dataPre.fieldConditions)) {
+                lomCount_1 += 1;
+            }
+        });
+        if (lomCount_1 >= dataPre.minQty && (lomCount_1 <= dataPre.maxQty || dataPre.maxQty === '*')) {
+            return true;
+        }
+    }
+    return false;
+}
+export function isUndefined(value) {
+    return value === undefined;
+}
+var defaultWeights = DEFAULT_RULE_WEIGHTS;
+export var computeScore = function (chartType, chartWIKI, ruleBase, ruleType, info, log) {
+    // initial score is 1 for HARD rules and 0 for SOFT rules
+    var computedScore = 1;
+    Object.values(ruleBase)
+        .filter(function (r) {
+        var _a, _b, _c;
+        var weight = ((_a = r.option) === null || _a === void 0 ? void 0 : _a.weight) || defaultWeights[r.id] || 1;
+        var extra = (_b = r.option) === null || _b === void 0 ? void 0 : _b.extra;
+        return r.type === ruleType && r.trigger(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartType: chartType, chartWIKI: chartWIKI })) && !((_c = r.option) === null || _c === void 0 ? void 0 : _c.off);
+    })
+        .forEach(function (r) {
+        var _a, _b;
+        var weight = ((_a = r.option) === null || _a === void 0 ? void 0 : _a.weight) || defaultWeights[r.id] || 1;
+        var extra = (_b = r.option) === null || _b === void 0 ? void 0 : _b.extra;
+        var base = r.validator(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartType: chartType, chartWIKI: chartWIKI }));
+        var score = weight * base;
+        computedScore *= score;
+        log.push({ phase: 'ADVISE', ruleId: r.id, score: score, base: base, weight: weight, ruleType: ruleType });
+    });
+    return computedScore;
+};

package/esm/advisor/types.js

@@ -0,0 +1 @@
+export * from './ruler/types';

package/esm/advisor/utils/clone.js

@@ -0,0 +1,32 @@
+var cloneDeep = function (obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return obj;
+    }
+    var result;
+    if (Array.isArray(obj)) {
+        result = [];
+        for (var i = 0, l = obj.length; i < l; i += 1) {
+            if (typeof obj[i] === 'object' && obj[i] != null) {
+                result[i] = cloneDeep(obj[i]);
+            }
+            else {
+                result[i] = obj[i];
+            }
+        }
+    }
+    else {
+        result = {};
+        var objKeys = Object.keys(obj);
+        for (var i = 0; i < objKeys.length; i += 1) {
+            var key = objKeys[i];
+            if (typeof obj[key] === 'object' && obj[key] != null) {
+                result[key] = cloneDeep(obj[key]);
+            }
+            else {
+                result[key] = obj[key];
+            }
+        }
+    }
+    return result;
+};
+export default cloneDeep;

package/esm/advisor/utils/compare.js

@@ -0,0 +1,14 @@
+import isNil from './isNil';
+var compare = function (f1, f2) {
+    if (isNil(f1.distinct) || isNil(f2.distinct)) {
+        if (f1.distinct < f2.distinct) {
+            return 1;
+        }
+        if (f1.distinct > f2.distinct) {
+            return -1;
+        }
+        return 0;
+    }
+    return 0;
+};
+export default compare;

package/esm/advisor/utils/computeScore.js

@@ -0,0 +1,25 @@
+import { __assign } from "tslib";
+import { DEFAULT_RULE_WEIGHTS } from '../constants';
+var defaultWeights = DEFAULT_RULE_WEIGHTS;
+var computeScore = function (chartType, chartWIKI, ruleBase, ruleType, info, log) {
+    // initial score is 1 for HARD rules and 0 for SOFT rules
+    var computedScore = 1;
+    Object.values(ruleBase)
+        .filter(function (r) {
+        var _a, _b, _c;
+        var weight = ((_a = r.option) === null || _a === void 0 ? void 0 : _a.weight) || defaultWeights[r.id] || 1;
+        var extra = (_b = r.option) === null || _b === void 0 ? void 0 : _b.extra;
+        return r.type === ruleType && r.trigger(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartType: chartType, chartWIKI: chartWIKI })) && !((_c = r.option) === null || _c === void 0 ? void 0 : _c.off);
+    })
+        .forEach(function (r) {
+        var _a, _b;
+        var weight = ((_a = r.option) === null || _a === void 0 ? void 0 : _a.weight) || defaultWeights[r.id] || 1;
+        var extra = (_b = r.option) === null || _b === void 0 ? void 0 : _b.extra;
+        var base = r.validator(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartType: chartType, chartWIKI: chartWIKI }));
+        var score = weight * base;
+        computedScore *= score;
+        log.push({ phase: 'ADVISE', ruleId: r.id, score: score, base: base, weight: weight, ruleType: ruleType });
+    });
+    return computedScore;
+};
+export default computeScore;

package/esm/advisor/utils/deep-mix.js

@@ -0,0 +1,76 @@
+/*
+ * implementation of deepMix in antv/utils
+ */
+var MAX_MIX_LEVEL = 5;
+var isObjectLike = function (value) {
+    /*
+     * isObjectLike({}) => true
+     * isObjectLike([1, 2, 3]) => true
+     * isObjectLike(Function) => false
+     * isObjectLike(null) => false
+     */
+    return typeof value === 'object' && value !== null;
+};
+var toString = {}.toString;
+var isType = function (value, type) { return toString.call(value) === "[object ".concat(type, "]"); };
+var isPlainObject = function (value) {
+    /*
+     * isObjectLike(new Foo) => false
+     * isObjectLike([1, 2, 3]) => false
+     * isObjectLike({ x: 0, y: 0 }) => true
+     * isObjectLike(Object.create(null)) => true
+     */
+    if (!isObjectLike(value) || !isType(value, 'Object')) {
+        return false;
+    }
+    if (Object.getPrototypeOf(value) === null) {
+        return true;
+    }
+    var proto = value;
+    while (Object.getPrototypeOf(proto) !== null) {
+        proto = Object.getPrototypeOf(proto);
+    }
+    return Object.getPrototypeOf(value) === proto;
+};
+var isArray = function (value) {
+    return Array.isArray ? Array.isArray(value) : isType(value, 'Array');
+};
+function pDeepMix(inputDist, src, inputLevel, inputMaxLevel) {
+    var level = inputLevel || 0;
+    var maxLevel = inputMaxLevel || MAX_MIX_LEVEL;
+    var dist = inputDist;
+    Object.keys(src).forEach(function (key) {
+        if (Object.prototype.hasOwnProperty.call(src, key)) {
+            var value = src[key];
+            if (value !== null && isPlainObject(value)) {
+                if (!isPlainObject(dist[key])) {
+                    dist[key] = {};
+                }
+                if (level < maxLevel) {
+                    pDeepMix(dist[key], value, level + 1, maxLevel);
+                }
+                else {
+                    dist[key] = src[key];
+                }
+            }
+            else if (isArray(value)) {
+                dist[key] = [];
+                dist[key] = dist[key].concat(value);
+            }
+            else if (value !== undefined) {
+                dist[key] = value;
+            }
+        }
+    });
+}
+var deepMix = function (rst) {
+    var args = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        args[_i - 1] = arguments[_i];
+    }
+    for (var i = 0; i < args.length; i += 1) {
+        pDeepMix(rst, args[i]);
+    }
+    return rst;
+};
+export default deepMix;

package/esm/advisor/utils/hasSubset.js

@@ -0,0 +1,3 @@
+export function hasSubset(array1, array2) {
+    return array2.every(function (e) { return array1.includes(e); });
+}

package/esm/advisor/utils/index.js

@@ -0,0 +1,8 @@
+/*
+ * TODO @GuangMingYouBei: migrate utils into one unified folder of in ava.
+ */
+export { default as deepMix } from './deep-mix';
+export { default as compare } from './compare';
+export { default as cloneDeep } from './clone';
+export { hasSubset } from './hasSubset';
+export { intersects } from './intersects';

package/esm/advisor/utils/inferDataType.js

@@ -0,0 +1,70 @@
+import { __assign } from "tslib";
+import { mapValues } from 'lodash';
+function isQuantitative(d) {
+    return typeof d === 'number';
+}
+function isCategorical(d) {
+    return typeof d === 'string' || typeof d === 'boolean';
+}
+function isTemporal(d) {
+    return d instanceof Date;
+}
+function isField(data, encode) {
+    return typeof encode === 'string' && data.some(function (d) { return d[encode] !== undefined; });
+}
+function isTransform(encode) {
+    return typeof encode === 'function';
+}
+// @ts-ignore: constant - 常数比例尺 / identity - 恒等比例尺 对用户不透出，所以此处ts-ignore
+function scaleType2dataType(scaleType) {
+    switch (scaleType) {
+        case 'linear':
+        case 'log':
+        case 'pow':
+        case 'sqrt':
+        case 'qunatile':
+        case 'threshold':
+        case 'quantize':
+        case 'sequential':
+            return 'quantitative';
+        case 'time':
+            return 'temporal';
+        case 'ordinal':
+        case 'point':
+        case 'band':
+            return 'categorical';
+        default:
+            throw new Error("Unkonwn scale type: ".concat(scaleType, "."));
+    }
+}
+function values2dataType(values) {
+    if (values.some(isQuantitative))
+        return 'quantitative';
+    if (values.some(isCategorical))
+        return 'categorical';
+    if (values.some(isTemporal))
+        return 'temporal';
+    throw new Error("Unknown type: ".concat(typeof values[0]));
+}
+function columnOf(data, encode) {
+    if (isTransform(encode))
+        return data.map(encode);
+    if (isField(data, encode))
+        return data.map(function (d) { return d[encode]; });
+    return data.map(function () { return encode; });
+}
+/** 推断数据类型 */
+export function inferDataType(data, encode, scale) {
+    if (scale !== undefined)
+        return scaleType2dataType(scale);
+    var values = columnOf(data, encode);
+    return values2dataType(values);
+}
+/** 获取带有字段类型的 chartSpec */
+export function getSpecWithEncodeType(chartSpec) {
+    var encode = chartSpec.encode, data = chartSpec.data, scale = chartSpec.scale;
+    var newEncode = mapValues(encode, function (value, key) {
+        return { field: value, type: inferDataType(data, value, scale === null || scale === void 0 ? void 0 : scale[key].type) };
+    });
+    return __assign(__assign({}, chartSpec), { encode: newEncode });
+}

package/esm/advisor/utils/intersects.js

@@ -0,0 +1,3 @@
+export function intersects(array1, array2) {
+    return array2.some(function (e) { return array1.includes(e); });
+}

package/esm/advisor/utils/isNil.js

@@ -0,0 +1,4 @@
+var isNil = function (input) {
+    return input === null;
+};
+export default isNil;