@formant/ava 3.4.1-formant

package/esm/advisor/lint-pipeline/getChartType.js

@@ -0,0 +1,109 @@
+var getPointChart = function (spec) {
+    if (spec.encode.size) {
+        return 'bubble_chart';
+    }
+    return 'scatter_plot';
+};
+/**
+ * 推荐所有 type 为 interval 的 spec 对应的具体图表类型
+ * type 为 interval的图表，可能为 column chart、bar chart、pie chart、donut chart
+ * @param spec
+ * @returns
+ */
+var getIntervalChart = function (spec) {
+    var _a;
+    /** 饼图类型推断 */
+    var coordinate = spec.coordinate;
+    if ((coordinate === null || coordinate === void 0 ? void 0 : coordinate.type) === 'theta') {
+        if (coordinate === null || coordinate === void 0 ? void 0 : coordinate.innerRadius) {
+            return 'donut_chart';
+        }
+        return 'pie_chart';
+    }
+    /** 柱状图、条形图类型推断 */
+    var transform = spec.transform;
+    var isBarChart = (_a = coordinate === null || coordinate === void 0 ? void 0 : coordinate.transform) === null || _a === void 0 ? void 0 : _a.some(function (item) { return item.type === 'transpose'; });
+    var isNormalized = transform === null || transform === void 0 ? void 0 : transform.some(function (item) { return item.type === 'normalizeY'; });
+    var isStacked = transform === null || transform === void 0 ? void 0 : transform.some(function (item) { return item.type === 'stackY'; });
+    var isGrouped = transform === null || transform === void 0 ? void 0 : transform.some(function (item) { return item.type === 'dodgeX'; });
+    if (isBarChart) {
+        // Bar
+        if (isGrouped)
+            return 'grouped_bar_chart';
+        if (isNormalized)
+            return 'stacked_bar_chart';
+        if (isStacked)
+            return 'percent_stacked_bar_chart';
+        return 'bar_chart';
+    }
+    // Column
+    if (isGrouped)
+        return 'grouped_column_chart';
+    if (isNormalized)
+        return 'stacked_column_chart';
+    if (isStacked)
+        return 'percent_stacked_column_chart';
+    return 'column_chart';
+};
+/**
+ * 推荐所有 type 为 area 的 spec 对应的具体图表类型
+ * @param spec
+ * @returns
+ */
+var getAreaChart = function (spec) {
+    var transform = spec.transform;
+    var isStacked = transform === null || transform === void 0 ? void 0 : transform.some(function (item) { return item.type === 'stackY'; });
+    var isNormalized = transform === null || transform === void 0 ? void 0 : transform.some(function (item) { return item.type === 'normalizeY'; });
+    if (isStacked) {
+        if (isNormalized) {
+            return 'percent_stacked_area_chart';
+        }
+        return 'stacked_area_chart';
+    }
+    return 'area_chart';
+};
+/**
+ * 推荐所有 type 为 line 的 spec 对应的具体图表类型
+ * @param spec
+ * @returns
+ */
+var getLineChart = function (spec) {
+    var encode = spec.encode;
+    if (encode.shape && encode.shape === 'hvh') {
+        return 'step_line_chart';
+    }
+    return 'line_chart';
+};
+/**
+ * 由于一种类型的 mark 可能对应多种可能的图表，所以需要此处进行转换
+ * @param spec
+ * @returns
+ */
+export var getChartType = function (spec) {
+    var chartType;
+    var chartSpec = spec;
+    var mark = chartSpec.type;
+    switch (mark) {
+        case 'area':
+            chartType = getAreaChart(chartSpec);
+            break;
+        case 'interval':
+            chartType = getIntervalChart(chartSpec);
+            break;
+        case 'line':
+            chartType = getLineChart(chartSpec);
+            break;
+        case 'point':
+            chartType = getPointChart(chartSpec);
+            break;
+        case 'rect':
+            chartType = 'histogram';
+            break;
+        case 'cell':
+            chartType = 'heatmap';
+            break;
+        default:
+            chartType = '';
+    }
+    return chartType;
+};

package/esm/advisor/lint-pipeline/lintRules.js

@@ -0,0 +1,32 @@
+import { __assign } from "tslib";
+export function lintRules(ruleBase, ruleTypeToLint, info, log, lints, ckb, spec) {
+    var judge = function (type) {
+        if (ruleTypeToLint === 'DESIGN') {
+            return type === 'DESIGN';
+        }
+        return type !== 'DESIGN';
+    };
+    Object.values(ruleBase)
+        .filter(function (r) {
+        var _a;
+        var _b = r.option || {}, weight = _b.weight, extra = _b.extra;
+        return judge(r.type) && !((_a = r.option) === null || _a === void 0 ? void 0 : _a.off) && r.trigger(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartWIKI: ckb }));
+    })
+        .forEach(function (r) {
+        var type = r.type, id = r.id, docs = r.docs;
+        var score;
+        if (ruleTypeToLint === 'DESIGN') {
+            var fix = r.optimizer(info.dataProps, spec);
+            // no fix -> means no violation
+            score = Object.keys(fix).length === 0 ? 1 : 0;
+            lints.push({ type: type, id: id, score: score, fix: fix, docs: docs });
+        }
+        else {
+            var _a = r.option || {}, weight = _a.weight, extra = _a.extra;
+            // no weight for linter's result
+            score = r.validator(__assign(__assign(__assign(__assign({}, info), { weight: weight }), extra), { chartWIKI: ckb }));
+            lints.push({ type: type, id: id, score: score, docs: docs });
+        }
+        log.push({ phase: 'LINT', ruleId: id, score: score, base: score, weight: 1, ruleType: type });
+    });
+}

package/esm/advisor/ruler/index.js

@@ -0,0 +1,74 @@
+import { __assign } from "tslib";
+import { rules } from './rules';
+export var builtInRules = Object.keys(rules);
+/**
+ *
+ * @param id rule id
+ * @returns the rule object or null if `id` not exist in built-in rules
+ */
+export var getChartRule = function (id) {
+    if (Object.keys(rules).includes(id)) {
+        return rules[id];
+    }
+    return null;
+};
+/**
+ *
+ * @param ids rule list
+ * @returns rule object list
+ */
+export var getChartRules = function (ids) {
+    var chartRules = {};
+    ids.forEach(function (id) {
+        if (Object.keys(rules).includes(id)) {
+            chartRules[id] = rules[id];
+        }
+    });
+    return chartRules;
+};
+/**
+ * processing ckb config and setup ckb used for advising
+ * @param ruleCfg rule configuration
+ * @returns rule base Record<string, RuleModule>
+ */
+export var processRuleCfg = function (ruleCfg) {
+    if (!ruleCfg) {
+        // no specific rule configuration -> return default rules
+        return getChartRules(builtInRules);
+    }
+    // step 1: remove excluded rule
+    var ruleBase = getChartRules(builtInRules);
+    if (ruleCfg.exclude) {
+        // have `exclude` definition
+        var toExclude = ruleCfg.exclude;
+        toExclude.forEach(function (id) {
+            if (Object.keys(ruleBase).includes(id)) {
+                delete ruleBase[id];
+            }
+        });
+    }
+    // step 2: remove rules that are not included
+    if (ruleCfg.include) {
+        var toInclude_1 = ruleCfg.include;
+        Object.keys(ruleBase).forEach(function (id) {
+            if (!toInclude_1.includes(id)) {
+                delete ruleBase[id];
+            }
+        });
+    }
+    // step 3: combine ruleBase and custom rules
+    var finalRuleBase = __assign(__assign({}, ruleBase), ruleCfg.custom);
+    // step 4: check options
+    var options = ruleCfg.options;
+    if (options) {
+        var ruleWithOption = Object.keys(options);
+        ruleWithOption.forEach(function (rule) {
+            if (Object.keys(finalRuleBase).includes(rule)) {
+                var ruleOption = options[rule];
+                finalRuleBase[rule] = __assign(__assign({}, finalRuleBase[rule]), { option: ruleOption });
+            }
+        });
+    }
+    return finalRuleBase;
+};
+export * from './types';

package/esm/advisor/ruler/rules/aggregation-single-row.js

@@ -0,0 +1,21 @@
+export var aggregationSingleRow = {
+    id: 'aggregation-single-row',
+    type: 'HARD',
+    docs: {
+        lintText: 'Recommend kpi_panel when only one row of aggregated data is available.',
+    },
+    trigger: function () {
+        return true;
+    },
+    validator: function (args) {
+        var result = 0;
+        var chartType = args.chartType, dataProps = args.dataProps;
+        if (dataProps.every(function (i) { return i.count === 1 && i.levelOfMeasurements.includes('Interval'); })) {
+            result = chartType === 'kpi_panel' ? 1 : 0.2;
+        }
+        else {
+            result = chartType === 'kpi_panel' ? 0 : 1;
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/all-can-be-table.js

@@ -0,0 +1,17 @@
+import { isUndefined } from '../utils';
+var applyChartTypes = ['table'];
+export var allCanBeTable = {
+    id: 'all-can-be-table',
+    type: 'HARD',
+    docs: {
+        lintText: 'all dataset can be table',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    validator: function (_a) {
+        var weight = _a.weight;
+        return isUndefined(weight) ? 1 : weight;
+    },
+};

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

@@ -0,0 +1,36 @@
+import { hasSubset } from '../../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = [
+    'bar_chart',
+    'grouped_bar_chart',
+    'stacked_bar_chart',
+    'percent_stacked_bar_chart',
+    'column_chart',
+    'grouped_column_chart',
+    'stacked_column_chart',
+    'percent_stacked_column_chart',
+];
+export var barSeriesQty = {
+    id: 'bar-series-qty',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Bar chart should has proper number of bars or bar groups.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps, chartType = args.chartType;
+        if (dataProps && chartType) {
+            var field4Series = dataProps.find(function (field) { return hasSubset(field.levelOfMeasurements, ['Nominal']); });
+            var seriesQty = field4Series && field4Series.count ? field4Series.count : 0;
+            if (seriesQty > 20) {
+                result = 20 / seriesQty;
+            }
+        }
+        result = result < 1 / MAX_SOFT_RULE_COEFFICIENT ? 1 / MAX_SOFT_RULE_COEFFICIENT : result;
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/bar-without-axis-min.js

@@ -0,0 +1,41 @@
+var applyChartTypes = [
+    'bar_chart',
+    'grouped_bar_chart',
+    'stacked_bar_chart',
+    'percent_stacked_bar_chart',
+    'column_chart',
+    'grouped_column_chart',
+    'stacked_column_chart',
+    'percent_stacked_column_chart',
+];
+export var barWithoutAxisMin = {
+    id: 'bar-without-axis-min',
+    type: 'DESIGN',
+    docs: {
+        lintText: 'It is not recommended to set the minimum value of axis for the bar or column chart.',
+        fixText: 'Remove the minimum value config of axis.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    optimizer: function (_, chartSpec) {
+        var _a, _b;
+        var scale = chartSpec.scale;
+        if (!scale)
+            return {};
+        // @ts-ignore 待 g2 发版后去掉@ts-ignore
+        var xMin = (_a = scale.x) === null || _a === void 0 ? void 0 : _a.domainMin;
+        //  @ts-ignore 同上
+        var yMin = (_b = scale.y) === null || _b === void 0 ? void 0 : _b.domainMin;
+        if (xMin || yMin) {
+            var newScale = JSON.parse(JSON.stringify(scale));
+            if (xMin)
+                newScale.x.domainMin = 0;
+            if (yMin)
+                newScale.y.domainMin = 0;
+            return { scale: newScale };
+        }
+        return {};
+    },
+};

package/esm/advisor/ruler/rules/constants.js

@@ -0,0 +1,6 @@
+/**
+ *  MAX_SOFT_RULE_COEFFICIENT is the max benifit coefficient for soft rule in advisor
+ *  correspondingly，
+ * （ 1 / MAX_SOFT_RULE_COEFFICIENT ）is the "max" penalty coefficient for soft rule in advisor
+ *  */
+export var MAX_SOFT_RULE_COEFFICIENT = 10;

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

@@ -0,0 +1,40 @@
+import { verifyDataProps } from '../utils';
+import { intersects } from '../../utils';
+export var dataCheck = {
+    id: 'data-check',
+    type: 'HARD',
+    docs: {
+        lintText: 'Data must satisfy the data prerequisites.',
+    },
+    trigger: function () {
+        return true;
+    },
+    validator: function (args) {
+        var result = 0;
+        var dataProps = args.dataProps, chartType = args.chartType, chartWIKI = args.chartWIKI;
+        if (dataProps && chartType && chartWIKI[chartType]) {
+            result = 1;
+            var dataPres_1 = chartWIKI[chartType].dataPres || [];
+            dataPres_1.forEach(function (dataPre) {
+                if (!verifyDataProps(dataPre, dataProps)) {
+                    result = 0;
+                }
+            });
+            var fieldsLOMs = dataProps.map(function (info) {
+                return info.levelOfMeasurements;
+            });
+            fieldsLOMs.forEach(function (fieldLOM) {
+                var flag = false;
+                dataPres_1.forEach(function (dataPre) {
+                    if (fieldLOM && intersects(fieldLOM, dataPre.fieldConditions)) {
+                        flag = true;
+                    }
+                });
+                if (!flag) {
+                    result = 0;
+                }
+            });
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/data-field-qty.js

@@ -0,0 +1,26 @@
+export var dataFieldQty = {
+    id: 'data-field-qty',
+    type: 'HARD',
+    docs: {
+        lintText: 'Data must have at least the min qty of the prerequisite.',
+    },
+    trigger: function () {
+        return true;
+    },
+    validator: function (args) {
+        var result = 0;
+        var dataProps = args.dataProps, chartType = args.chartType, chartWIKI = args.chartWIKI;
+        if (dataProps && chartType && chartWIKI[chartType]) {
+            result = 1;
+            var dataPres = chartWIKI[chartType].dataPres || [];
+            var minFieldQty = dataPres.map(function (e) { return e.minQty; }).reduce(function (acc, cv) { return acc + cv; });
+            if (dataProps.length) {
+                var fieldQty = dataProps.length;
+                if (fieldQty >= minFieldQty) {
+                    result = 1;
+                }
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/diff-pie-sector.js

@@ -0,0 +1,33 @@
+import { hasSubset } from '../../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = ['pie_chart', 'donut_chart'];
+export var diffPieSector = {
+    id: 'diff-pie-sector',
+    type: 'SOFT',
+    docs: {
+        lintText: 'The difference between sectors of a pie chart should be large enough.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps;
+        if (dataProps) {
+            var intervalField = dataProps.find(function (field) { return hasSubset(field.levelOfMeasurements, ['Interval']); });
+            if (intervalField && intervalField.sum && intervalField.rawData) {
+                var sum = intervalField.sum;
+                var scale_1 = 1 / sum;
+                var scaledSamples = intervalField.rawData.map(function (v) { return v * scale_1; });
+                var scaledProduct = scaledSamples.reduce(function (a, c) { return a * c; });
+                var count = intervalField.rawData.length;
+                var maxProduct = Math.pow((1 / count), count);
+                // Math.abs(maxProduct - Math.abs(scaledProduct)) / maxProduct 这个值 小于 0.5 会被认为有点问题
+                result = MAX_SOFT_RULE_COEFFICIENT * 0.2 * (Math.abs(maxProduct - Math.abs(scaledProduct)) / maxProduct);
+            }
+        }
+        result = result < 1 / MAX_SOFT_RULE_COEFFICIENT ? 1 / MAX_SOFT_RULE_COEFFICIENT : result;
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/index.js

@@ -0,0 +1,68 @@
+import { __read, __spreadArray } from "tslib";
+// Chart rules (hard and soft)
+// table and kpi_panel not include currently
+// import { aggregationSingleRow } from './aggregation-single-row';
+// import { allCanBeTable } from './all-can-be-table';
+import { barSeriesQty } from './bar-series-qty';
+import { barWithoutAxisMin } from './bar-without-axis-min';
+import { dataCheck } from './data-check';
+import { dataFieldQty } from './data-field-qty';
+import { diffPieSector } from './diff-pie-sector';
+import { landscapeOrPortrait } from './landscape-or-portrait';
+import { limitSeries } from './limit-series';
+import { lineFieldTimeOrdinal } from './line-field-time-ordinal';
+import { noRedundantField } from './no-redundant-field';
+import { nominalEnumCombinatorial } from './nominal-enum-combinatorial';
+import { purposeCheck } from './purpose-check';
+import { seriesQtyLimit } from './series-qty-limit';
+// Design rules
+import { xAxisLineFading } from './x-axis-line-fading';
+/** hard rules for validating chart type */
+var HARD_RULE_ID = [
+    // table and kpi_panel not include currently
+    // 'aggregation-single-row',
+    // 'all-can-be-table',
+    'data-check',
+    'data-field-qty',
+    'no-redundant-field',
+    'purpose-check',
+];
+/** soft rules for scoring chart type */
+var SOFT_RULE_ID = [
+    'series-qty-limit',
+    'bar-series-qty',
+    'line-field-time-ordinal',
+    'landscape-or-portrait',
+    'diff-pie-sector',
+    'nominal-enum-combinatorial',
+    'limit-series',
+];
+/**
+ * @public
+ */
+export var CHART_RULE_ID = __spreadArray(__spreadArray([], __read(HARD_RULE_ID), false), __read(SOFT_RULE_ID), false);
+/**
+ * @public
+ */
+export var CHART_DESIGN_RULE_ID = ['x-axis-line-fading', 'bar-without-axis-min'];
+export var rules = {
+    /** -- hard rules -- */
+    // table and kpi_panel not include currently
+    // 'aggregation-single-row': aggregationSingleRow,
+    // 'all-can-be-table': allCanBeTable,
+    'data-check': dataCheck,
+    'data-field-qty': dataFieldQty,
+    'no-redundant-field': noRedundantField,
+    'purpose-check': purposeCheck,
+    /** -- soft rules -- */
+    'bar-series-qty': barSeriesQty,
+    'diff-pie-sector': diffPieSector,
+    'landscape-or-portrait': landscapeOrPortrait,
+    'limit-series': limitSeries,
+    'line-field-time-ordinal': lineFieldTimeOrdinal,
+    'nominal-enum-combinatorial': nominalEnumCombinatorial,
+    'series-qty-limit': seriesQtyLimit,
+    /** -- design rules -- */
+    'x-axis-line-fading': xAxisLineFading,
+    'bar-without-axis-min': barWithoutAxisMin,
+};

package/esm/advisor/ruler/rules/landscape-or-portrait.js

@@ -0,0 +1,40 @@
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = [
+    'bar_chart',
+    'grouped_bar_chart',
+    'stacked_bar_chart',
+    'percent_stacked_bar_chart',
+    'column_chart',
+    'grouped_column_chart',
+    'stacked_column_chart',
+    'percent_stacked_column_chart',
+];
+function hasCanvasLayout(_a) {
+    var chartType = _a.chartType, dataProps = _a.dataProps, preferences = _a.preferences;
+    return !!(dataProps && chartType && preferences && preferences.canvasLayout);
+}
+export var landscapeOrPortrait = {
+    id: 'landscape-or-portrait',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Recommend column charts for landscape layout and bar charts for portrait layout.',
+    },
+    trigger: function (info) {
+        return applyChartTypes.includes(info.chartType) && hasCanvasLayout(info);
+    },
+    validator: function (args) {
+        var result = 1;
+        var chartType = args.chartType, preferences = args.preferences;
+        if (hasCanvasLayout(args)) {
+            if (preferences.canvasLayout === 'portrait' &&
+                ['bar_chart', 'grouped_bar_chart', 'stacked_bar_chart', 'percent_stacked_bar_chart'].includes(chartType)) {
+                result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+            }
+            else if (preferences.canvasLayout === 'landscape' &&
+                ['column_chart', 'grouped_column_chart', 'stacked_column_chart', 'percent_stacked_column_chart'].includes(chartType)) {
+                result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+            }
+        }
+        return result;
+    },
+};

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

@@ -0,0 +1,47 @@
+import { intersects } from '../../utils';
+import { compare } from '../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+function hasSeriesField(dataProps) {
+    var nominalOrOrdinalFields = dataProps.filter(function (field) {
+        return intersects(field.levelOfMeasurements, ['Nominal', 'Ordinal']);
+    });
+    return nominalOrOrdinalFields.length >= 2;
+}
+/*
+只有 heatmap 能映射两个 维值非常多的 字段，因为对于 其他图表，如柱状图来说，第二个维度字段 就要映射成 颜色了。而颜色不适合映射特别多的维度。
+所以，在有 两个 维度字段的时候，在两个维度的维值都很多的情况下，要给 heatmap 加分，给其他图表减分。
+ */
+export var limitSeries = {
+    id: 'limit-series',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Avoid too many values in one series.',
+    },
+    trigger: function (_a) {
+        var dataProps = _a.dataProps;
+        return hasSeriesField(dataProps);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps, chartType = args.chartType;
+        if (dataProps) {
+            var nominalOrOrdinalFields = dataProps.filter(function (field) {
+                return intersects(field.levelOfMeasurements, ['Nominal', 'Ordinal']);
+            });
+            if (nominalOrOrdinalFields.length >= 2) {
+                var sortedFields = nominalOrOrdinalFields.sort(compare);
+                var f = sortedFields[1];
+                if (f.distinct) {
+                    result = f.distinct > MAX_SOFT_RULE_COEFFICIENT ? 1 / MAX_SOFT_RULE_COEFFICIENT : 1 / f.distinct;
+                    if (f.distinct > 6 && chartType === 'heatmap') {
+                        result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+                    }
+                    else if (chartType === 'heatmap') {
+                        result = 1;
+                    }
+                }
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/line-field-time-ordinal.js

@@ -0,0 +1,25 @@
+import { intersects } from '../../utils';
+import { MAX_SOFT_RULE_COEFFICIENT } from './constants';
+var applyChartTypes = ['line_chart', 'area_chart', 'stacked_area_chart', 'percent_stacked_area_chart'];
+export var lineFieldTimeOrdinal = {
+    id: 'line-field-time-ordinal',
+    type: 'SOFT',
+    docs: {
+        lintText: 'Data containing time or ordinal fields are suitable for line or area charts.',
+    },
+    trigger: function (_a) {
+        var chartType = _a.chartType;
+        return applyChartTypes.includes(chartType);
+    },
+    validator: function (args) {
+        var result = 1;
+        var dataProps = args.dataProps;
+        if (dataProps) {
+            var field4TimeOrOrdinal = dataProps.find(function (field) { return intersects(field.levelOfMeasurements, ['Ordinal', 'Time']); });
+            if (field4TimeOrOrdinal) {
+                result = MAX_SOFT_RULE_COEFFICIENT * 0.5;
+            }
+        }
+        return result;
+    },
+};

package/esm/advisor/ruler/rules/no-redundant-field.js

@@ -0,0 +1,32 @@
+export var noRedundantField = {
+    id: 'no-redundant-field',
+    type: 'HARD',
+    docs: {
+        lintText: 'No redundant field.',
+    },
+    trigger: function () {
+        return true;
+    },
+    validator: function (args) {
+        var result = 0;
+        var dataProps = args.dataProps, chartType = args.chartType, chartWIKI = args.chartWIKI;
+        if (dataProps && chartType && chartWIKI[chartType]) {
+            var dataPres = chartWIKI[chartType].dataPres || [];
+            var maxFieldQty = dataPres
+                .map(function (e) {
+                if (e.maxQty === '*') {
+                    return 99;
+                }
+                return e.maxQty;
+            })
+                .reduce(function (acc, cv) { return acc + cv; });
+            if (dataProps.length) {
+                var fieldQty = dataProps.length;
+                if (fieldQty <= maxFieldQty) {
+                    result = 1;
+                }
+            }
+        }
+        return result;
+    },
+};