@formant/ava 3.4.1-formant

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

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChartType = void 0;
+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
+ */
+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;
+};
+exports.getChartType = getChartType;

package/lib/advisor/lint-pipeline/lintRules.d.ts

@@ -0,0 +1,5 @@
+import { Info, RuleModule } from '../ruler';
+import type { Specification } from '../../common/types';
+import type { ScoringResultForRule, Lint } from '../types';
+import type { ChartKnowledgeBase } from '../../ckb';
+export declare function lintRules(ruleBase: Record<string, RuleModule>, ruleTypeToLint: 'notDESIGN' | 'DESIGN', info: Info, log: ScoringResultForRule[], lints: Lint[], ckb: ChartKnowledgeBase, spec?: Specification): void;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lintRules = void 0;
+var tslib_1 = require("tslib");
+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(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__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(tslib_1.__assign(tslib_1.__assign(tslib_1.__assign(tslib_1.__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 });
+    });
+}
+exports.lintRules = lintRules;

package/lib/advisor/ruler/index.d.ts

@@ -0,0 +1,21 @@
+import type { RuleModule, RuleConfig } from './types';
+export declare const builtInRules: string[];
+/**
+ *
+ * @param id rule id
+ * @returns the rule object or null if `id` not exist in built-in rules
+ */
+export declare const getChartRule: (id: string) => RuleModule | null;
+/**
+ *
+ * @param ids rule list
+ * @returns rule object list
+ */
+export declare const getChartRules: (ids: string[]) => Record<string, RuleModule>;
+/**
+ * processing ckb config and setup ckb used for advising
+ * @param ruleCfg rule configuration
+ * @returns rule base Record<string, RuleModule>
+ */
+export declare const processRuleCfg: (ruleCfg?: RuleConfig) => Record<string, RuleModule>;
+export * from './types';

package/lib/advisor/ruler/index.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRuleCfg = exports.getChartRules = exports.getChartRule = exports.builtInRules = void 0;
+var tslib_1 = require("tslib");
+var rules_1 = require("./rules");
+exports.builtInRules = Object.keys(rules_1.rules);
+/**
+ *
+ * @param id rule id
+ * @returns the rule object or null if `id` not exist in built-in rules
+ */
+var getChartRule = function (id) {
+    if (Object.keys(rules_1.rules).includes(id)) {
+        return rules_1.rules[id];
+    }
+    return null;
+};
+exports.getChartRule = getChartRule;
+/**
+ *
+ * @param ids rule list
+ * @returns rule object list
+ */
+var getChartRules = function (ids) {
+    var chartRules = {};
+    ids.forEach(function (id) {
+        if (Object.keys(rules_1.rules).includes(id)) {
+            chartRules[id] = rules_1.rules[id];
+        }
+    });
+    return chartRules;
+};
+exports.getChartRules = getChartRules;
+/**
+ * processing ckb config and setup ckb used for advising
+ * @param ruleCfg rule configuration
+ * @returns rule base Record<string, RuleModule>
+ */
+var processRuleCfg = function (ruleCfg) {
+    if (!ruleCfg) {
+        // no specific rule configuration -> return default rules
+        return (0, exports.getChartRules)(exports.builtInRules);
+    }
+    // step 1: remove excluded rule
+    var ruleBase = (0, exports.getChartRules)(exports.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 = tslib_1.__assign(tslib_1.__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] = tslib_1.__assign(tslib_1.__assign({}, finalRuleBase[rule]), { option: ruleOption });
+            }
+        });
+    }
+    return finalRuleBase;
+};
+exports.processRuleCfg = processRuleCfg;
+tslib_1.__exportStar(require("./types"), exports);

package/lib/advisor/ruler/rules/aggregation-single-row.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const aggregationSingleRow: RuleModule;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregationSingleRow = void 0;
+exports.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/lib/advisor/ruler/rules/all-can-be-table.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const allCanBeTable: RuleModule;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.allCanBeTable = void 0;
+var utils_1 = require("../utils");
+var applyChartTypes = ['table'];
+exports.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 (0, utils_1.isUndefined)(weight) ? 1 : weight;
+    },
+};

package/lib/advisor/ruler/rules/bar-series-qty.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const barSeriesQty: RuleModule;

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.barSeriesQty = void 0;
+var utils_1 = require("../../utils");
+var constants_1 = require("./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',
+];
+exports.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 (0, utils_1.hasSubset)(field.levelOfMeasurements, ['Nominal']); });
+            var seriesQty = field4Series && field4Series.count ? field4Series.count : 0;
+            if (seriesQty > 20) {
+                result = 20 / seriesQty;
+            }
+        }
+        result = result < 1 / constants_1.MAX_SOFT_RULE_COEFFICIENT ? 1 / constants_1.MAX_SOFT_RULE_COEFFICIENT : result;
+        return result;
+    },
+};

package/lib/advisor/ruler/rules/bar-without-axis-min.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const barWithoutAxisMin: RuleModule;

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.barWithoutAxisMin = void 0;
+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',
+];
+exports.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/lib/advisor/ruler/rules/constants.d.ts

@@ -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 declare const MAX_SOFT_RULE_COEFFICIENT = 10;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SOFT_RULE_COEFFICIENT = void 0;
+/**
+ *  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
+ *  */
+exports.MAX_SOFT_RULE_COEFFICIENT = 10;

package/lib/advisor/ruler/rules/data-check.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const dataCheck: RuleModule;

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataCheck = void 0;
+var utils_1 = require("../utils");
+var utils_2 = require("../../utils");
+exports.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 (!(0, utils_1.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 && (0, utils_2.intersects)(fieldLOM, dataPre.fieldConditions)) {
+                        flag = true;
+                    }
+                });
+                if (!flag) {
+                    result = 0;
+                }
+            });
+        }
+        return result;
+    },
+};

package/lib/advisor/ruler/rules/data-field-qty.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const dataFieldQty: RuleModule;

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataFieldQty = void 0;
+exports.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/lib/advisor/ruler/rules/diff-pie-sector.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const diffPieSector: RuleModule;

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffPieSector = void 0;
+var utils_1 = require("../../utils");
+var constants_1 = require("./constants");
+var applyChartTypes = ['pie_chart', 'donut_chart'];
+exports.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 (0, utils_1.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 = constants_1.MAX_SOFT_RULE_COEFFICIENT * 0.2 * (Math.abs(maxProduct - Math.abs(scaledProduct)) / maxProduct);
+            }
+        }
+        result = result < 1 / constants_1.MAX_SOFT_RULE_COEFFICIENT ? 1 / constants_1.MAX_SOFT_RULE_COEFFICIENT : result;
+        return result;
+    },
+};

package/lib/advisor/ruler/rules/index.d.ts

@@ -0,0 +1,19 @@
+import type { RuleModule } from '../types';
+/**
+ * @public
+ */
+export declare const CHART_RULE_ID: readonly string[];
+/**
+ * @public
+ */
+export type ChartRuleID = (typeof CHART_RULE_ID)[number];
+/**
+ * @public
+ */
+export declare const CHART_DESIGN_RULE_ID: readonly ["x-axis-line-fading", "bar-without-axis-min"];
+/**
+ * @public
+ */
+export type ChartDesignRuleID = (typeof CHART_DESIGN_RULE_ID)[number];
+export type RuleId = ChartRuleID | ChartDesignRuleID;
+export declare const rules: Partial<Record<RuleId, RuleModule>>;

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rules = exports.CHART_DESIGN_RULE_ID = exports.CHART_RULE_ID = void 0;
+var tslib_1 = require("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';
+var bar_series_qty_1 = require("./bar-series-qty");
+var bar_without_axis_min_1 = require("./bar-without-axis-min");
+var data_check_1 = require("./data-check");
+var data_field_qty_1 = require("./data-field-qty");
+var diff_pie_sector_1 = require("./diff-pie-sector");
+var landscape_or_portrait_1 = require("./landscape-or-portrait");
+var limit_series_1 = require("./limit-series");
+var line_field_time_ordinal_1 = require("./line-field-time-ordinal");
+var no_redundant_field_1 = require("./no-redundant-field");
+var nominal_enum_combinatorial_1 = require("./nominal-enum-combinatorial");
+var purpose_check_1 = require("./purpose-check");
+var series_qty_limit_1 = require("./series-qty-limit");
+// Design rules
+var x_axis_line_fading_1 = require("./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
+ */
+exports.CHART_RULE_ID = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(HARD_RULE_ID), false), tslib_1.__read(SOFT_RULE_ID), false);
+/**
+ * @public
+ */
+exports.CHART_DESIGN_RULE_ID = ['x-axis-line-fading', 'bar-without-axis-min'];
+exports.rules = {
+    /** -- hard rules -- */
+    // table and kpi_panel not include currently
+    // 'aggregation-single-row': aggregationSingleRow,
+    // 'all-can-be-table': allCanBeTable,
+    'data-check': data_check_1.dataCheck,
+    'data-field-qty': data_field_qty_1.dataFieldQty,
+    'no-redundant-field': no_redundant_field_1.noRedundantField,
+    'purpose-check': purpose_check_1.purposeCheck,
+    /** -- soft rules -- */
+    'bar-series-qty': bar_series_qty_1.barSeriesQty,
+    'diff-pie-sector': diff_pie_sector_1.diffPieSector,
+    'landscape-or-portrait': landscape_or_portrait_1.landscapeOrPortrait,
+    'limit-series': limit_series_1.limitSeries,
+    'line-field-time-ordinal': line_field_time_ordinal_1.lineFieldTimeOrdinal,
+    'nominal-enum-combinatorial': nominal_enum_combinatorial_1.nominalEnumCombinatorial,
+    'series-qty-limit': series_qty_limit_1.seriesQtyLimit,
+    /** -- design rules -- */
+    'x-axis-line-fading': x_axis_line_fading_1.xAxisLineFading,
+    'bar-without-axis-min': bar_without_axis_min_1.barWithoutAxisMin,
+};

package/lib/advisor/ruler/rules/landscape-or-portrait.d.ts

@@ -0,0 +1,2 @@
+import type { RuleModule } from '../types';
+export declare const landscapeOrPortrait: RuleModule;