@formant/ava 3.4.1-formant

package/lib/insight/chart/constants.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PIE_RADIUS_STYLE = exports.ChartTypeMap = exports.TEXT_STYLE = exports.BOLD_FONT_WEIGHT = exports.INSIGHT_COLOR_PLATTE = void 0;
+exports.INSIGHT_COLOR_PLATTE = {
+    highlight: '#E09322',
+    outlier: '#CB5140',
+    font: '#2C3542',
+    defaultPointColor: '#fff',
+};
+exports.BOLD_FONT_WEIGHT = 500;
+exports.TEXT_STYLE = {
+    textAlign: 'center',
+    fill: exports.INSIGHT_COLOR_PLATTE.font,
+    opacity: 0.65,
+};
+exports.ChartTypeMap = {
+    category_outlier: 'column_chart',
+    trend: 'line_chart',
+    change_point: 'line_chart',
+    time_series_outlier: 'line_chart',
+    majority: 'pie_chart',
+    low_variance: 'column_chart',
+    correlation: 'scatter_plot',
+};
+exports.PIE_RADIUS_STYLE = {
+    innerRadius: 0.25,
+    outerRadius: 0.8,
+};

package/lib/insight/chart/generator/homogeneous.d.ts

@@ -0,0 +1,3 @@
+import { HomogeneousPatternInfo, InsightInfo, InsightVisualizationSpec } from '../../types';
+export declare function generateHomogeneousInsightAugmentedMarks(pattern: HomogeneousPatternInfo): any[];
+export declare function generateHomogeneousInsightChartSpec(insight: InsightInfo<HomogeneousPatternInfo>, pattern: HomogeneousPatternInfo): InsightVisualizationSpec[];

package/lib/insight/chart/generator/homogeneous.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHomogeneousInsightChartSpec = exports.generateHomogeneousInsightAugmentedMarks = void 0;
+var tslib_1 = require("tslib");
+var constants_1 = require("../constants");
+function generateHomogeneousInsightAugmentedMarks(pattern) {
+    var annotations = [];
+    var insightType = pattern.insightType, childPatterns = pattern.childPatterns;
+    if (['change_point', 'time_series_outlier'].includes(insightType)) {
+        var x_1 = childPatterns[0].x;
+        var text = insightType === 'change_point' ? 'Abrupt Change' : 'Outlier';
+        var color_1 = insightType === 'change_point' ? constants_1.INSIGHT_COLOR_PLATTE.highlight : constants_1.INSIGHT_COLOR_PLATTE.outlier;
+        // draw line
+        var line = {
+            type: 'line',
+            start: [x_1, 'min'],
+            end: [x_1, 'max'],
+            text: {
+                content: text,
+                position: 'left',
+                offsetY: 15,
+                offsetX: 5,
+                rotate: 0,
+                autoRotate: false,
+                style: {
+                    textAlign: 'left',
+                },
+            },
+        };
+        annotations.push(line);
+        // draw circle
+        var circles = childPatterns.map(function (pattern) {
+            var y = pattern.y;
+            return {
+                type: 'dataMarker',
+                position: [x_1, y],
+                point: {
+                    style: {
+                        fill: '#fff',
+                        stroke: color_1,
+                    },
+                },
+                line: {
+                    length: 20,
+                },
+                autoAdjust: false,
+            };
+        });
+        annotations.push.apply(annotations, tslib_1.__spreadArray([], tslib_1.__read(circles), false));
+    }
+    return annotations;
+}
+exports.generateHomogeneousInsightAugmentedMarks = generateHomogeneousInsightAugmentedMarks;
+function generateHomogeneousInsightChartSpec(insight, pattern) {
+    var dimensions = insight.dimensions, measures = insight.measures;
+    var plotSchema;
+    if (measures.length > 1) {
+        plotSchema = {
+            xField: dimensions[0],
+            yField: 'value',
+            seriesField: 'measureName',
+        };
+    }
+    else {
+        plotSchema = {
+            xField: dimensions[1],
+            yField: measures[0].fieldName,
+            seriesField: dimensions[0],
+        };
+    }
+    var annotationConfig = generateHomogeneousInsightAugmentedMarks(pattern);
+    var chartSchema = tslib_1.__assign(tslib_1.__assign({}, plotSchema), { annotations: annotationConfig });
+    return chartSchema;
+}
+exports.generateHomogeneousInsightChartSpec = generateHomogeneousInsightChartSpec;

package/lib/insight/chart/generator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './homogeneous';
+export * from './insights';

package/lib/insight/chart/generator/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./homogeneous"), exports);
+tslib_1.__exportStar(require("./insights"), exports);

package/lib/insight/chart/generator/insights.d.ts

@@ -0,0 +1,3 @@
+import { G2Spec } from '@antv/g2';
+import { InsightInfo, PatternInfo } from '../../types';
+export declare function generateInsightChartSpec(insight: InsightInfo<PatternInfo>): G2Spec;

package/lib/insight/chart/generator/insights.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInsightChartSpec = void 0;
+var strategy_1 = require("../strategy");
+function generateInsightChartSpec(insight) {
+    var _a;
+    var insightType = insight.patterns[0].type;
+    var insightType2Strategy = {
+        trend: strategy_1.trendStrategy,
+        time_series_outlier: strategy_1.timeSeriesOutlierStrategy,
+        category_outlier: strategy_1.categoryOutlierStrategy,
+        change_point: strategy_1.changePointStrategy,
+        low_variance: strategy_1.lowVarianceStrategy,
+        majority: strategy_1.majorityStrategy,
+        correlation: strategy_1.correlationStrategy,
+    };
+    var marks = (_a = insightType2Strategy[insightType]) === null || _a === void 0 ? void 0 : _a.call(insightType2Strategy, insight);
+    return (0, strategy_1.viewSpecStrategy)(marks, insight);
+}
+exports.generateInsightChartSpec = generateInsightChartSpec;

package/lib/insight/chart/index.d.ts

@@ -0,0 +1,4 @@
+export * from './generator/homogeneous';
+export * from './generator/insights';
+export * from './strategy/augmentedMarks';
+export * from './types';

package/lib/insight/chart/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./generator/homogeneous"), exports);
+tslib_1.__exportStar(require("./generator/insights"), exports);
+tslib_1.__exportStar(require("./strategy/augmentedMarks"), exports);
+tslib_1.__exportStar(require("./types"), exports);

package/lib/insight/chart/strategy/augmentedMarks/categoryOutlier.d.ts

@@ -0,0 +1,5 @@
+import { Mark } from '@antv/g2';
+import { InsightInfo, CategoryOutlierInfo } from '../../../types';
+import { CategoryOutlierMark } from '../../types';
+export declare const categoryOutlierAugmentedMarksStrategy: (insight: InsightInfo<CategoryOutlierInfo>) => CategoryOutlierMark[];
+export declare const categoryOutlierStrategy: (insight: InsightInfo<CategoryOutlierInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/categoryOutlier.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.categoryOutlierStrategy = exports.categoryOutlierAugmentedMarksStrategy = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var utils_1 = require("../../../../utils");
+var constants_1 = require("../../constants");
+var chart_1 = require("../chart");
+var commonMarks_1 = require("../commonMarks");
+var utils_2 = require("../../utils");
+var categoryOutlierAugmentedMarksStrategy = function (insight) {
+    var patterns = insight.patterns;
+    if (!(0, lodash_1.size)(patterns))
+        return [];
+    var categoryOutlierMarks = [];
+    patterns.forEach(function (pattern) {
+        var rectMark = (0, commonMarks_1.intervalMarkStrategy)([pattern]);
+        var textMark = (0, commonMarks_1.textMarkStrategy)([pattern], {
+            style: { fontWeight: constants_1.BOLD_FONT_WEIGHT, dy: -8 },
+            formatter: utils_1.dataFormat,
+        });
+        categoryOutlierMarks.push({
+            categoryOutlier: [rectMark, textMark],
+        });
+    });
+    return categoryOutlierMarks;
+};
+exports.categoryOutlierAugmentedMarksStrategy = categoryOutlierAugmentedMarksStrategy;
+var categoryOutlierStrategy = function (insight) {
+    var chart = (0, chart_1.insight2ChartStrategy)(insight);
+    var categoryOutlierMarks = (0, exports.categoryOutlierAugmentedMarksStrategy)(insight);
+    var marks = (0, utils_2.augmentedMarks2Marks)(categoryOutlierMarks);
+    return tslib_1.__spreadArray([chart], tslib_1.__read(marks), false);
+};
+exports.categoryOutlierStrategy = categoryOutlierStrategy;

package/lib/insight/chart/strategy/augmentedMarks/changePoint.d.ts

@@ -0,0 +1,5 @@
+import { Mark } from '@antv/g2';
+import { ChangePointInfo, InsightInfo } from '../../../types';
+import { ChangePointMark } from '../../types';
+export declare const changePointAugmentedMarksStrategy: (insight: InsightInfo<ChangePointInfo>) => ChangePointMark[];
+export declare const changePointStrategy: (insight: InsightInfo<ChangePointInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/changePoint.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changePointStrategy = exports.changePointAugmentedMarksStrategy = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var constants_1 = require("../../constants");
+var utils_1 = require("../../../../utils");
+var pointMark_1 = require("../commonMarks/pointMark");
+var textMark_1 = require("../commonMarks/textMark");
+var chart_1 = require("../chart");
+var utils_2 = require("../../utils");
+var changePointAugmentedMarksStrategy = function (insight) {
+    var patterns = insight.patterns;
+    var color = constants_1.INSIGHT_COLOR_PLATTE.highlight;
+    if (!(0, lodash_1.size)(patterns))
+        return [];
+    var measure = patterns[0].measure;
+    var changePointMarks = [];
+    patterns.forEach(function (pattern) {
+        var pointMark = (0, pointMark_1.pointMarkStrategy)([pattern], { style: { fill: color } });
+        var textMark = (0, textMark_1.textMarkStrategy)([pattern], {
+            formatter: utils_1.dataFormat,
+            label: function (pt) { return "".concat(pt.x, ", ").concat(measure, ": ").concat(pt.y); },
+            style: {
+                dy: -20,
+                background: true,
+                backgroundRadius: 2,
+                connector: true,
+                startMarker: true,
+                startMarkerFill: '#2C3542',
+                startMarkerFillOpacity: 0.65,
+            },
+        });
+        changePointMarks.push({
+            changePoint: [pointMark, textMark],
+        });
+    });
+    return changePointMarks;
+};
+exports.changePointAugmentedMarksStrategy = changePointAugmentedMarksStrategy;
+var changePointStrategy = function (insight) {
+    var chart = (0, chart_1.insight2ChartStrategy)(insight);
+    var changePointMarks = (0, exports.changePointAugmentedMarksStrategy)(insight);
+    var marks = (0, utils_2.augmentedMarks2Marks)(changePointMarks);
+    return tslib_1.__spreadArray([chart], tslib_1.__read(marks), false);
+};
+exports.changePointStrategy = changePointStrategy;

package/lib/insight/chart/strategy/augmentedMarks/correlation.d.ts

@@ -0,0 +1,3 @@
+import { Mark } from '@antv/g2';
+import { CorrelationInfo, InsightInfo } from '../../../types';
+export declare const correlationStrategy: (insight: InsightInfo<CorrelationInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/correlation.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.correlationStrategy = void 0;
+var chart_1 = require("../chart");
+var correlationStrategy = function (insight) {
+    // todo add correlation regression line and value
+    var chartMark = (0, chart_1.insight2ChartStrategy)(insight);
+    return [chartMark];
+};
+exports.correlationStrategy = correlationStrategy;

package/lib/insight/chart/strategy/augmentedMarks/homogeneous.d.ts

@@ -0,0 +1,3 @@
+import { G2Spec } from '@antv/g2';
+import { HomogeneousPatternInfo, InsightInfo } from '../../../types';
+export declare const homogeneousStrategy: (_insight: InsightInfo<HomogeneousPatternInfo>) => G2Spec;

package/lib/insight/chart/strategy/augmentedMarks/homogeneous.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.homogeneousStrategy = void 0;
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+var homogeneousStrategy = function (_insight) {
+    // colorField: string
+    return {};
+};
+exports.homogeneousStrategy = homogeneousStrategy;

package/lib/insight/chart/strategy/augmentedMarks/index.d.ts

@@ -0,0 +1,8 @@
+export { trendStrategy, trendAugmentedMarksStrategy } from './trend';
+export { lowVarianceStrategy, lowVarianceAugmentedMarkStrategy } from './lowVariance';
+export { categoryOutlierStrategy, categoryOutlierAugmentedMarksStrategy } from './categoryOutlier';
+export { changePointStrategy, changePointAugmentedMarksStrategy } from './changePoint';
+export { majorityStrategy } from './majority';
+export { correlationStrategy } from './correlation';
+export { homogeneousStrategy } from './homogeneous';
+export { timeSeriesOutlierStrategy, timeSeriesOutlierStrategyAugmentedMarksStrategy } from './timeSeriesOutlier';

package/lib/insight/chart/strategy/augmentedMarks/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeSeriesOutlierStrategyAugmentedMarksStrategy = exports.timeSeriesOutlierStrategy = exports.homogeneousStrategy = exports.correlationStrategy = exports.majorityStrategy = exports.changePointAugmentedMarksStrategy = exports.changePointStrategy = exports.categoryOutlierAugmentedMarksStrategy = exports.categoryOutlierStrategy = exports.lowVarianceAugmentedMarkStrategy = exports.lowVarianceStrategy = exports.trendAugmentedMarksStrategy = exports.trendStrategy = void 0;
+var trend_1 = require("./trend");
+Object.defineProperty(exports, "trendStrategy", { enumerable: true, get: function () { return trend_1.trendStrategy; } });
+Object.defineProperty(exports, "trendAugmentedMarksStrategy", { enumerable: true, get: function () { return trend_1.trendAugmentedMarksStrategy; } });
+var lowVariance_1 = require("./lowVariance");
+Object.defineProperty(exports, "lowVarianceStrategy", { enumerable: true, get: function () { return lowVariance_1.lowVarianceStrategy; } });
+Object.defineProperty(exports, "lowVarianceAugmentedMarkStrategy", { enumerable: true, get: function () { return lowVariance_1.lowVarianceAugmentedMarkStrategy; } });
+var categoryOutlier_1 = require("./categoryOutlier");
+Object.defineProperty(exports, "categoryOutlierStrategy", { enumerable: true, get: function () { return categoryOutlier_1.categoryOutlierStrategy; } });
+Object.defineProperty(exports, "categoryOutlierAugmentedMarksStrategy", { enumerable: true, get: function () { return categoryOutlier_1.categoryOutlierAugmentedMarksStrategy; } });
+var changePoint_1 = require("./changePoint");
+Object.defineProperty(exports, "changePointStrategy", { enumerable: true, get: function () { return changePoint_1.changePointStrategy; } });
+Object.defineProperty(exports, "changePointAugmentedMarksStrategy", { enumerable: true, get: function () { return changePoint_1.changePointAugmentedMarksStrategy; } });
+var majority_1 = require("./majority");
+Object.defineProperty(exports, "majorityStrategy", { enumerable: true, get: function () { return majority_1.majorityStrategy; } });
+var correlation_1 = require("./correlation");
+Object.defineProperty(exports, "correlationStrategy", { enumerable: true, get: function () { return correlation_1.correlationStrategy; } });
+var homogeneous_1 = require("./homogeneous");
+Object.defineProperty(exports, "homogeneousStrategy", { enumerable: true, get: function () { return homogeneous_1.homogeneousStrategy; } });
+var timeSeriesOutlier_1 = require("./timeSeriesOutlier");
+Object.defineProperty(exports, "timeSeriesOutlierStrategy", { enumerable: true, get: function () { return timeSeriesOutlier_1.timeSeriesOutlierStrategy; } });
+Object.defineProperty(exports, "timeSeriesOutlierStrategyAugmentedMarksStrategy", { enumerable: true, get: function () { return timeSeriesOutlier_1.timeSeriesOutlierStrategyAugmentedMarksStrategy; } });

package/lib/insight/chart/strategy/augmentedMarks/lowVariance.d.ts

@@ -0,0 +1,5 @@
+import { Mark } from '@antv/g2';
+import { LowVarianceInfo, InsightInfo } from '../../../types';
+import { LowVarianceMark } from '../../types';
+export declare const lowVarianceAugmentedMarkStrategy: (insight: InsightInfo<LowVarianceInfo>) => LowVarianceMark[];
+export declare const lowVarianceStrategy: (insight: InsightInfo<LowVarianceInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/lowVariance.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lowVarianceStrategy = exports.lowVarianceAugmentedMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var commonMarks_1 = require("../commonMarks");
+var chart_1 = require("../chart");
+var utils_1 = require("../../utils");
+var utils_2 = require("../../../../utils");
+var lowVarianceAugmentedMarkStrategy = function (insight) {
+    var patterns = insight.patterns;
+    var marks = [];
+    patterns.forEach(function (pattern) {
+        var mean = pattern.mean;
+        var meanLineMark = (0, commonMarks_1.lineMarkStrategy)({ y: mean }, { label: "mean: ".concat((0, utils_2.dataFormat)(mean)) });
+        marks.push({
+            meanLine: [meanLineMark],
+        });
+    });
+    return marks;
+};
+exports.lowVarianceAugmentedMarkStrategy = lowVarianceAugmentedMarkStrategy;
+var lowVarianceStrategy = function (insight) {
+    var chartMark = (0, chart_1.insight2ChartStrategy)(insight);
+    var lowVarianceMarks = (0, exports.lowVarianceAugmentedMarkStrategy)(insight);
+    var marks = (0, utils_1.augmentedMarks2Marks)(lowVarianceMarks);
+    return tslib_1.__spreadArray([chartMark], tslib_1.__read(marks), false);
+};
+exports.lowVarianceStrategy = lowVarianceStrategy;

package/lib/insight/chart/strategy/augmentedMarks/majority.d.ts

@@ -0,0 +1,3 @@
+import { Mark } from '@antv/g2';
+import { MajorityInfo, InsightInfo } from '../../../types';
+export declare const majorityStrategy: (insight: InsightInfo<MajorityInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/majority.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.majorityStrategy = void 0;
+var chart_1 = require("../chart");
+var majorityStrategy = function (insight) {
+    var chartMark = (0, chart_1.insight2ChartStrategy)(insight);
+    return [chartMark];
+};
+exports.majorityStrategy = majorityStrategy;

package/lib/insight/chart/strategy/augmentedMarks/timeSeriesOutlier.d.ts

@@ -0,0 +1,5 @@
+import { Mark } from '@antv/g2';
+import { TimeSeriesOutlierInfo, InsightInfo } from '../../../types';
+import { TimeSeriesOutlierMark } from '../../types';
+export declare const timeSeriesOutlierStrategyAugmentedMarksStrategy: (insight: InsightInfo<TimeSeriesOutlierInfo>) => TimeSeriesOutlierMark[];
+export declare const timeSeriesOutlierStrategy: (insight: InsightInfo<TimeSeriesOutlierInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/timeSeriesOutlier.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.timeSeriesOutlierStrategy = exports.timeSeriesOutlierStrategyAugmentedMarksStrategy = void 0;
+var tslib_1 = require("tslib");
+var chart_1 = require("../chart");
+var commonMarks_1 = require("../commonMarks");
+var BASELINE = 'baseline';
+var INTERVAL = 'interval';
+var OUTLIER = 'outlier';
+var timeSeriesOutlierStrategyAugmentedMarksStrategy = function (insight) {
+    var chartData = insight.data, _a = tslib_1.__read(insight.dimensions, 1), dimensionName = _a[0].fieldName, patterns = insight.patterns;
+    var _b = patterns[0], baselines = _b.baselines, thresholds = _b.thresholds;
+    var data = chartData.map(function (datum, index) {
+        var baseline = baselines[index];
+        var interval = [baseline - Math.abs(thresholds[0]), baseline + thresholds[1]];
+        return {
+            baseline: {
+                x: datum[dimensionName],
+                y: baseline,
+            },
+            interval: {
+                x: datum[dimensionName],
+                y: interval,
+            },
+        };
+    });
+    var intervalData = data.map(function (datum) { return datum[INTERVAL]; });
+    var intervalMark = (0, commonMarks_1.areaMarkStrategy)(intervalData, {
+        encode: {
+            shape: 'smooth',
+        },
+        style: {
+            fillOpacity: 0.3,
+            fill: '#ffd8b8',
+        },
+        tooltip: {
+            title: '',
+            items: [
+                function (_d, i, _data, column) { return ({
+                    name: INTERVAL,
+                    value: "".concat(column.y.value[i], "-").concat(column.y1.value[i]),
+                    color: '#ffd8b8',
+                }); },
+            ],
+        },
+    });
+    var baselineData = data.map(function (datum) { return datum[BASELINE]; });
+    var baselineMark = (0, commonMarks_1.lineMarkStrategy)({ points: baselineData }, {
+        encode: {
+            shape: 'smooth',
+        },
+        style: {
+            lineWidth: 1,
+            stroke: '#ffa45c',
+            lineDash: undefined,
+        },
+        tooltip: {
+            title: '',
+            items: [{ name: BASELINE, channel: 'y' }],
+        },
+    });
+    var outlierMark = (0, commonMarks_1.pointMarkStrategy)(patterns, {
+        style: {
+            fill: '#f4664a',
+            stroke: '#f4664a',
+        },
+        tooltip: {
+            title: '',
+            items: [{ name: OUTLIER, channel: 'y' }],
+        },
+    });
+    return [
+        {
+            trendLine: [baselineMark],
+            anomalyArea: [intervalMark],
+            outliers: [outlierMark],
+        },
+    ];
+};
+exports.timeSeriesOutlierStrategyAugmentedMarksStrategy = timeSeriesOutlierStrategyAugmentedMarksStrategy;
+var timeSeriesOutlierStrategy = function (insight) {
+    // Should to support marks free combination
+    var chartMark = (0, chart_1.insight2ChartStrategy)(insight);
+    var _a = (0, exports.timeSeriesOutlierStrategyAugmentedMarksStrategy)(insight)[0] || {}, _b = _a.trendLine, trendLine = _b === void 0 ? [] : _b, _c = _a.anomalyArea, anomalyArea = _c === void 0 ? [] : _c, _e = _a.outliers, outliers = _e === void 0 ? [] : _e;
+    return tslib_1.__spreadArray(tslib_1.__spreadArray(tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(anomalyArea), false), tslib_1.__read(trendLine), false), [chartMark], false), tslib_1.__read(outliers), false);
+};
+exports.timeSeriesOutlierStrategy = timeSeriesOutlierStrategy;

package/lib/insight/chart/strategy/augmentedMarks/trend.d.ts

@@ -0,0 +1,5 @@
+import { Mark } from '@antv/g2';
+import { InsightInfo, TrendInfo } from '../../../types';
+import { TrendMark } from '../../types';
+export declare const trendAugmentedMarksStrategy: (insight: InsightInfo<TrendInfo>) => TrendMark[];
+export declare const trendStrategy: (insight: InsightInfo<TrendInfo>) => Mark[];

package/lib/insight/chart/strategy/augmentedMarks/trend.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trendStrategy = exports.trendAugmentedMarksStrategy = void 0;
+var tslib_1 = require("tslib");
+var commonMarks_1 = require("../commonMarks");
+var chart_1 = require("../chart");
+var utils_1 = require("../../../../utils");
+var trendAugmentedMarksStrategy = function (insight) {
+    var chartData = insight.data, _a = tslib_1.__read(insight.dimensions, 1), dimensionName = _a[0].fieldName, patterns = insight.patterns;
+    var points = chartData.map(function (datum, index) {
+        var points = patterns[0].regression.points;
+        var point = points[index];
+        return [datum[dimensionName], point];
+    });
+    var _b = tslib_1.__read(patterns[0].regression.equation, 2), m = _b[0], c = _b[1];
+    var lineData = points.map(function (point) { return ({ x: point[0], y: point[1] }); });
+    var regressionLineMark = (0, commonMarks_1.lineMarkStrategy)({ points: lineData }, { label: "y=".concat((0, utils_1.dataFormat)(m), "x").concat(c < 0 ? '' : '+').concat((0, utils_1.dataFormat)(c)) });
+    return [
+        {
+            trendLine: [regressionLineMark],
+        },
+    ];
+};
+exports.trendAugmentedMarksStrategy = trendAugmentedMarksStrategy;
+var trendStrategy = function (insight) {
+    var _a, _b;
+    var chart = (0, chart_1.insight2ChartStrategy)(insight);
+    var trendMarks = (0, exports.trendAugmentedMarksStrategy)(insight);
+    return tslib_1.__spreadArray([chart], tslib_1.__read(((_b = (_a = trendMarks[0]) === null || _a === void 0 ? void 0 : _a.trendLine) !== null && _b !== void 0 ? _b : [])), false);
+};
+exports.trendStrategy = trendStrategy;

package/lib/insight/chart/strategy/chart.d.ts

@@ -0,0 +1,7 @@
+import { Mark } from '@antv/g2';
+import { InsightInfo, InsightType } from '../../types';
+export declare const insight2ChartStrategy: (insight: Omit<InsightInfo<import("../../types").PatternInfo>, "patterns" | "visualizationSpecs"> & {
+    patterns: {
+        type: InsightType;
+    }[];
+}) => Mark;

package/lib/insight/chart/strategy/chart.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insight2ChartStrategy = void 0;
+var tslib_1 = require("tslib");
+var constants_1 = require("../constants");
+var insight2ChartStrategy = function (insight) {
+    var _a, _b;
+    var data = insight.data, patterns = insight.patterns, dimensions = insight.dimensions, measures = insight.measures;
+    var insightType = patterns[0].type;
+    var commonSpec = {
+        data: data,
+        encode: {
+            x: dimensions[0].fieldName,
+            y: measures[0].fieldName,
+        },
+    };
+    // pie
+    if (insightType === 'majority') {
+        return tslib_1.__assign(tslib_1.__assign({}, commonSpec), { type: 'interval', encode: {
+                color: dimensions[0].fieldName,
+                y: measures[0].fieldName,
+            }, transform: [{ type: 'stackY' }], coordinate: {
+                type: 'theta',
+                innerRadius: constants_1.PIE_RADIUS_STYLE.innerRadius,
+                outerRadius: constants_1.PIE_RADIUS_STYLE.outerRadius,
+            }, tooltip: {
+                items: [{ field: dimensions[0].fieldName }, { field: measures[0].fieldName }],
+            } });
+    }
+    // line
+    if (insightType === 'trend' || insightType === 'time_series_outlier' || insightType === 'change_point') {
+        return tslib_1.__assign(tslib_1.__assign({}, commonSpec), { type: 'line', style: {
+                lineWidth: 2,
+            } });
+    }
+    // bar
+    if (insightType === 'category_outlier' || insightType === 'low_variance') {
+        return tslib_1.__assign(tslib_1.__assign({}, commonSpec), { type: 'interval' });
+    }
+    // scatter
+    if (insightType === 'correlation') {
+        return tslib_1.__assign(tslib_1.__assign({}, commonSpec), { type: 'point', encode: {
+                x: (_a = measures[0]) === null || _a === void 0 ? void 0 : _a.fieldName,
+                y: (_b = measures[1]) === null || _b === void 0 ? void 0 : _b.fieldName,
+            } });
+    }
+    return null;
+};
+exports.insight2ChartStrategy = insight2ChartStrategy;

package/lib/insight/chart/strategy/commonMarks/areaMark.d.ts

@@ -0,0 +1,3 @@
+import { AreaMark } from '@antv/g2';
+import { AreaMarkData, AreaMarkConfig } from '../../types';
+export declare const areaMarkStrategy: (data: AreaMarkData, { encode, style, tooltip }: AreaMarkConfig) => AreaMark;

package/lib/insight/chart/strategy/commonMarks/areaMark.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areaMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var areaMarkStrategy = function (data, _a) {
+    var encode = _a.encode, style = _a.style, tooltip = _a.tooltip;
+    var common = {
+        style: style,
+        tooltip: tooltip,
+    };
+    if (data) {
+        return tslib_1.__assign(tslib_1.__assign({}, common), { type: 'area', data: data, encode: tslib_1.__assign({ x: 'x', y: 'y' }, encode) });
+    }
+    return null;
+};
+exports.areaMarkStrategy = areaMarkStrategy;

package/lib/insight/chart/strategy/commonMarks/index.d.ts

@@ -0,0 +1,5 @@
+export { lineMarkStrategy } from './lineMark';
+export { pointMarkStrategy } from './pointMark';
+export { textMarkStrategy } from './textMark';
+export { areaMarkStrategy } from './areaMark';
+export { intervalMarkStrategy } from './intervalMark';

package/lib/insight/chart/strategy/commonMarks/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalMarkStrategy = exports.areaMarkStrategy = exports.textMarkStrategy = exports.pointMarkStrategy = exports.lineMarkStrategy = void 0;
+var lineMark_1 = require("./lineMark");
+Object.defineProperty(exports, "lineMarkStrategy", { enumerable: true, get: function () { return lineMark_1.lineMarkStrategy; } });
+var pointMark_1 = require("./pointMark");
+Object.defineProperty(exports, "pointMarkStrategy", { enumerable: true, get: function () { return pointMark_1.pointMarkStrategy; } });
+var textMark_1 = require("./textMark");
+Object.defineProperty(exports, "textMarkStrategy", { enumerable: true, get: function () { return textMark_1.textMarkStrategy; } });
+var areaMark_1 = require("./areaMark");
+Object.defineProperty(exports, "areaMarkStrategy", { enumerable: true, get: function () { return areaMark_1.areaMarkStrategy; } });
+var intervalMark_1 = require("./intervalMark");
+Object.defineProperty(exports, "intervalMarkStrategy", { enumerable: true, get: function () { return intervalMark_1.intervalMarkStrategy; } });

package/lib/insight/chart/strategy/commonMarks/intervalMark.d.ts

@@ -0,0 +1,5 @@
+import { RectMark } from '@antv/g2';
+import { PointPatternInfo } from '../../../types';
+import { IntervalMarkConfig } from '../../types';
+/** get mark for point patterns, the patterns should have same dimension and measure */
+export declare const intervalMarkStrategy: (patterns: PointPatternInfo[], config?: IntervalMarkConfig) => RectMark;