@formant/ava 3.4.20-formant → 3.5.0-formant

package/esm/insight/chart/constants.js

@@ -1,26 +1,5 @@
-export var INSIGHT_COLOR_PLATTE = {
-    highlight: '#f89973',
-    outlier: '#ea719d',
-    font: '#bac4e2',
-    defaultPointColor: '#fff',
-};
-export var BOLD_FONT_WEIGHT = 500;
-export var TEXT_STYLE = {
-    textAlign: 'center',
-    fill: INSIGHT_COLOR_PLATTE.font,
-    fontFamily: 'Moderat',
-    opacity: 0.85,
-};
-export var 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',
-};
-export var PIE_RADIUS_STYLE = {
+/** pie radii as fractions of the available radius */
+export var PIE_RADIUS = {
     innerRadius: 0.25,
     outerRadius: 0.8,
 };

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

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

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

@@ -1,6 +1,6 @@
 import { categoryOutlierStrategy, changePointStrategy, lowVarianceStrategy, majorityStrategy, correlationStrategy, timeSeriesOutlierStrategy, trendStrategy, viewSpecStrategy, } from '../strategy';
 export function generateInsightChartSpec(insight) {
-    var _a;
+    var _a, _b;
     var insightType = insight.patterns[0].type;
     var insightType2Strategy = {
         trend: trendStrategy,
@@ -11,6 +11,6 @@ export function generateInsightChartSpec(insight) {
         majority: majorityStrategy,
         correlation: correlationStrategy,
     };
-    var marks = (_a = insightType2Strategy[insightType]) === null || _a === void 0 ? void 0 : _a.call(insightType2Strategy, insight);
+    var marks = (_b = (_a = insightType2Strategy[insightType]) === null || _a === void 0 ? void 0 : _a.call(insightType2Strategy, insight)) !== null && _b !== void 0 ? _b : [];
     return viewSpecStrategy(marks, insight);
 }

package/esm/insight/chart/index.js

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

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

@@ -1,24 +1,18 @@
 import { __read, __spreadArray } from "tslib";
 import { size } from 'lodash';
 import { insight2ChartStrategy } from '../chart';
-import { intervalMarkStrategy } from '../commonMarks';
+import { barMarkStrategy } from '../commonMarks';
 import { augmentedMarks2Marks } from '../../utils';
 export var categoryOutlierAugmentedMarksStrategy = function (insight) {
     var patterns = insight.patterns;
     if (!size(patterns))
         return [];
-    var categoryOutlierMarks = [];
-    patterns.forEach(function (pattern) {
-        var rectMark = intervalMarkStrategy([pattern]);
-        categoryOutlierMarks.push({
-            categoryOutlier: [rectMark],
-        });
-    });
-    return categoryOutlierMarks;
+    return patterns.map(function (pattern) { return ({
+        categoryOutlier: [barMarkStrategy([pattern], { role: 'outlier', name: 'outlier' })],
+    }); });
 };
 export var categoryOutlierStrategy = function (insight) {
     var chart = insight2ChartStrategy(insight);
-    var categoryOutlierMarks = categoryOutlierAugmentedMarksStrategy(insight);
-    var marks = augmentedMarks2Marks(categoryOutlierMarks);
+    var marks = augmentedMarks2Marks(categoryOutlierAugmentedMarksStrategy(insight));
     return __spreadArray([chart], __read(marks), false);
 };

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

@@ -1,42 +1,26 @@
 import { __read, __spreadArray } from "tslib";
 import { size } from 'lodash';
-import { INSIGHT_COLOR_PLATTE } from '../../constants';
 import { dataFormat } from '../../../../utils';
-import { pointMarkStrategy } from '../commonMarks/pointMark';
-import { textMarkStrategy } from '../commonMarks/textMark';
+import { pointMarkStrategy } from '../commonMarks';
 import { insight2ChartStrategy } from '../chart';
 import { augmentedMarks2Marks } from '../../utils';
 export var changePointAugmentedMarksStrategy = function (insight) {
     var patterns = insight.patterns;
-    var color = INSIGHT_COLOR_PLATTE.highlight;
     if (!size(patterns))
         return [];
     var measure = patterns[0].measure;
-    var changePointMarks = [];
-    patterns.forEach(function (pattern) {
-        var pointMark = pointMarkStrategy([pattern], { style: { fill: color } });
-        var textMark = textMarkStrategy([pattern], {
-            formatter: 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: '#1c1e2d',
-                startMarkerFillOpacity: 0.65,
-            },
-        });
-        changePointMarks.push({
-            changePoint: [pointMark, textMark],
-        });
-    });
-    return changePointMarks;
+    return patterns.map(function (pattern) { return ({
+        changePoint: [
+            pointMarkStrategy([pattern], {
+                role: 'highlight',
+                name: 'change point',
+                label: function (pt) { return "".concat(pt.x, ", ").concat(measure, ": ").concat(dataFormat(pt.y)); },
+            }),
+        ],
+    }); });
 };
 export var changePointStrategy = function (insight) {
     var chart = insight2ChartStrategy(insight);
-    var changePointMarks = changePointAugmentedMarksStrategy(insight);
-    var marks = augmentedMarks2Marks(changePointMarks);
+    var marks = augmentedMarks2Marks(changePointAugmentedMarksStrategy(insight));
     return __spreadArray([chart], __read(marks), false);
 };

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

@@ -1,6 +1,5 @@
 import { insight2ChartStrategy } from '../chart';
 export var correlationStrategy = function (insight) {
     // todo add correlation regression line and value
-    var chartMark = insight2ChartStrategy(insight);
-    return [chartMark];
+    return [insight2ChartStrategy(insight)];
 };

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

@@ -4,5 +4,4 @@ export { categoryOutlierStrategy, categoryOutlierAugmentedMarksStrategy } from '
 export { changePointStrategy, changePointAugmentedMarksStrategy } from './changePoint';
 export { majorityStrategy } from './majority';
 export { correlationStrategy } from './correlation';
-export { homogeneousStrategy } from './homogeneous';
 export { timeSeriesOutlierStrategy, timeSeriesOutlierStrategyAugmentedMarksStrategy } from './timeSeriesOutlier';

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

@@ -1,23 +1,18 @@
 import { __read, __spreadArray } from "tslib";
-import { lineMarkStrategy } from '../commonMarks';
+import { ruleYMarkStrategy } from '../commonMarks';
 import { insight2ChartStrategy } from '../chart';
 import { augmentedMarks2Marks } from '../../utils';
 import { dataFormat } from '../../../../utils';
 export var lowVarianceAugmentedMarkStrategy = function (insight) {
-    var patterns = insight.patterns;
-    var marks = [];
-    patterns.forEach(function (pattern) {
-        var mean = pattern.mean;
-        var meanLineMark = lineMarkStrategy({ y: mean }, { label: "mean: ".concat(dataFormat(mean)) });
-        marks.push({
-            meanLine: [meanLineMark],
+    return insight.patterns.map(function (_a) {
+        var mean = _a.mean;
+        return ({
+            meanLine: [ruleYMarkStrategy(mean, { role: 'mean', name: 'mean', label: "mean: ".concat(dataFormat(mean)) })],
         });
     });
-    return marks;
 };
 export var lowVarianceStrategy = function (insight) {
     var chartMark = insight2ChartStrategy(insight);
-    var lowVarianceMarks = lowVarianceAugmentedMarkStrategy(insight);
-    var marks = augmentedMarks2Marks(lowVarianceMarks);
+    var marks = augmentedMarks2Marks(lowVarianceAugmentedMarkStrategy(insight));
     return __spreadArray([chartMark], __read(marks), false);
 };

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

@@ -1,5 +1,4 @@
 import { insight2ChartStrategy } from '../chart';
 export var majorityStrategy = function (insight) {
-    var chartMark = insight2ChartStrategy(insight);
-    return [chartMark];
+    return [insight2ChartStrategy(insight)];
 };

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

@@ -1,82 +1,25 @@
 import { __read, __spreadArray } from "tslib";
 import { insight2ChartStrategy } from '../chart';
 import { areaMarkStrategy, lineMarkStrategy, pointMarkStrategy } from '../commonMarks';
-var BASELINE = 'baseline';
-var INTERVAL = 'interval';
-var OUTLIER = 'outlier';
 export var timeSeriesOutlierStrategyAugmentedMarksStrategy = function (insight) {
     var chartData = insight.data, _a = __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 = 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 = lineMarkStrategy({ points: baselineData }, {
-        encode: {
-            shape: 'smooth',
-        },
-        style: {
-            lineWidth: 1,
-            stroke: '#ffa45c',
-            lineDash: undefined,
-        },
-        tooltip: {
-            title: '',
-            items: [{ name: BASELINE, channel: 'y' }],
-        },
-    });
-    var outlierMark = pointMarkStrategy(patterns, {
-        style: {
-            fill: '#f4664a',
-            stroke: '#f4664a',
-        },
-        tooltip: {
-            title: '',
-            items: [{ name: OUTLIER, channel: 'y' }],
-        },
-    });
+    var intervalData = chartData.map(function (datum, index) { return ({
+        x: datum[dimensionName],
+        y0: baselines[index] - Math.abs(thresholds[0]),
+        y1: baselines[index] + thresholds[1],
+    }); });
+    var baselineData = chartData.map(function (datum, index) { return ({ x: datum[dimensionName], y: baselines[index] }); });
     return [
         {
-            trendLine: [baselineMark],
-            anomalyArea: [intervalMark],
-            outliers: [outlierMark],
+            trendLine: [lineMarkStrategy(baselineData, { role: 'baseline', name: 'baseline', smooth: true })],
+            anomalyArea: [areaMarkStrategy(intervalData, { role: 'band', name: 'interval', smooth: true })],
+            outliers: [pointMarkStrategy(patterns, { role: 'outlier', name: 'outlier' })],
         },
     ];
 };
 export var timeSeriesOutlierStrategy = function (insight) {
-    // Should to support marks free combination
     var chartMark = insight2ChartStrategy(insight);
-    var _a = 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;
+    var _a = timeSeriesOutlierStrategyAugmentedMarksStrategy(insight)[0] || {}, _b = _a.trendLine, trendLine = _b === void 0 ? [] : _b, _c = _a.anomalyArea, anomalyArea = _c === void 0 ? [] : _c, _d = _a.outliers, outliers = _d === void 0 ? [] : _d;
     return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(anomalyArea), false), __read(trendLine), false), [chartMark], false), __read(outliers), false);
 };

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

@@ -4,17 +4,17 @@ import { insight2ChartStrategy } from '../chart';
 import { dataFormat } from '../../../../utils';
 export var trendAugmentedMarksStrategy = function (insight) {
     var chartData = insight.data, _a = __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 = __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 = lineMarkStrategy({ points: lineData }, { label: "y=".concat(dataFormat(m), "x").concat(c < 0 ? '' : '+').concat(dataFormat(c)) });
+    var _b = patterns[0].regression, points = _b.points, _c = __read(_b.equation, 2), m = _c[0], c = _c[1];
+    var lineData = chartData.map(function (datum, index) { return ({ x: datum[dimensionName], y: points[index] }); });
     return [
         {
-            trendLine: [regressionLineMark],
+            trendLine: [
+                lineMarkStrategy(lineData, {
+                    role: 'trend',
+                    name: 'trend',
+                    label: "y=".concat(dataFormat(m), "x").concat(c < 0 ? '' : '+').concat(dataFormat(c)),
+                }),
+            ],
         },
     ];
 };

package/esm/insight/chart/strategy/chart.js

@@ -1,45 +1,34 @@
 import { __assign } from "tslib";
-import { PIE_RADIUS_STYLE } from '../constants';
+import { PIE_RADIUS } from '../constants';
+/** the mark that draws the insight data itself */
 export var insight2ChartStrategy = function (insight) {
-    var _a, _b;
+    var _a, _b, _c;
     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,
-        },
-    };
+    var dimension = (_a = dimensions[0]) === null || _a === void 0 ? void 0 : _a.fieldName;
+    var measure = (_b = measures[0]) === null || _b === void 0 ? void 0 : _b.fieldName;
+    var points = function () { return data.map(function (datum) { return ({ x: datum[dimension], y: Number(datum[measure]) }); }); };
     // pie
     if (insightType === 'majority') {
-        return __assign(__assign({}, commonSpec), { type: 'interval', encode: {
-                color: dimensions[0].fieldName,
-                y: measures[0].fieldName,
-            }, transform: [{ type: 'stackY' }], coordinate: {
-                type: 'theta',
-                innerRadius: PIE_RADIUS_STYLE.innerRadius,
-                outerRadius: PIE_RADIUS_STYLE.outerRadius,
-            }, tooltip: {
-                items: [{ field: dimensions[0].fieldName }, { field: measures[0].fieldName }],
-            } });
+        return __assign({ type: 'arc', role: 'primary', name: measure, data: data.map(function (datum) { return ({ name: String(datum[dimension]), value: Number(datum[measure]) }); }) }, PIE_RADIUS);
     }
     // line
     if (insightType === 'trend' || insightType === 'time_series_outlier' || insightType === 'change_point') {
-        return __assign(__assign({}, commonSpec), { type: 'line', style: {
-                lineWidth: 2,
-            } });
+        return { type: 'line', role: 'primary', name: measure, data: points() };
     }
     // bar
     if (insightType === 'category_outlier' || insightType === 'low_variance') {
-        return __assign(__assign({}, commonSpec), { type: 'interval' });
+        return { type: 'bar', role: 'primary', name: measure, data: points() };
     }
     // scatter
     if (insightType === 'correlation') {
-        return __assign(__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,
-            } });
+        var yMeasure_1 = (_c = measures[1]) === null || _c === void 0 ? void 0 : _c.fieldName;
+        return {
+            type: 'point',
+            role: 'primary',
+            name: "".concat(measure, " / ").concat(yMeasure_1),
+            data: data.map(function (datum) { return ({ x: Number(datum[measure]), y: Number(datum[yMeasure_1]) }); }),
+        };
     }
     return null;
 };

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

@@ -1,12 +1,2 @@
 import { __assign } from "tslib";
-export var areaMarkStrategy = function (data, _a) {
-    var encode = _a.encode, style = _a.style, tooltip = _a.tooltip;
-    var common = {
-        style: style,
-        tooltip: tooltip,
-    };
-    if (data) {
-        return __assign(__assign({}, common), { type: 'area', data: data, encode: __assign({ x: 'x', y: 'y' }, encode) });
-    }
-    return null;
-};
+export var areaMarkStrategy = function (data, config) { return (__assign({ type: 'area', data: data }, config)); };

package/esm/insight/chart/strategy/commonMarks/barMark.js

@@ -0,0 +1,6 @@
+import { __assign } from "tslib";
+/** get mark for point patterns, the patterns should have same dimension and measure */
+export var barMarkStrategy = function (patterns, config) { return (__assign({ type: 'bar', data: patterns.map(function (_a) {
+        var x = _a.x, y = _a.y;
+        return ({ x: x, y: y });
+    }) }, config)); };

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

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

package/esm/insight/chart/strategy/commonMarks/lineMark.js

@@ -1,34 +1,2 @@
 import { __assign } from "tslib";
-import { INSIGHT_COLOR_PLATTE } from '../../constants';
-export var lineMarkStrategy = function (_a, _b) {
-    var points = _a.points, x = _a.x, y = _a.y;
-    var encode = _b.encode, style = _b.style, label = _b.label, tooltip = _b.tooltip;
-    var common = {
-        style: __assign({ lineDash: [2, 2], stroke: INSIGHT_COLOR_PLATTE.highlight }, style),
-        labels: label
-            ? [
-                {
-                    text: label,
-                    selector: 'last',
-                    position: 'right',
-                    style: {
-                        textBaseline: 'bottom',
-                        textAlign: 'end',
-                        dy: -24,
-                    },
-                },
-            ]
-            : undefined,
-        tooltip: tooltip,
-    };
-    if (points) {
-        return __assign(__assign({}, common), { type: 'line', data: points, encode: __assign({ x: 'x', y: 'y' }, encode) });
-    }
-    if (x) {
-        return __assign(__assign({}, common), { type: 'lineX', data: [x] });
-    }
-    if (y) {
-        return __assign(__assign({}, common), { type: 'lineY', data: [y] });
-    }
-    return null;
-};
+export var lineMarkStrategy = function (data, config) { return (__assign({ type: 'line', data: data }, config)); };

package/esm/insight/chart/strategy/commonMarks/pointMark.js

@@ -1,17 +1,13 @@
-import { __assign } from "tslib";
+import { __assign, __rest } from "tslib";
 import { isNil } from 'lodash';
 /** get mark for point patterns, the patterns should have same dimension and measure */
 export var pointMarkStrategy = function (patterns, config) {
-    var data = [];
-    patterns.forEach(function (_a) {
+    var label = config.label, markConfig = __rest(config, ["label"]);
+    var data = patterns
+        .filter(function (_a) {
         var x = _a.x, y = _a.y;
-        if (isNil(x) || isNil(y))
-            return;
-        data.push({ x: x, y: y });
-    });
-    var pointMark = __assign({ type: 'point', data: data, encode: {
-            x: 'x',
-            y: 'y',
-        } }, config);
-    return pointMark;
+        return !isNil(x) && !isNil(y);
+    })
+        .map(function (pattern) { return (__assign({ x: pattern.x, y: pattern.y }, (label ? { label: label(pattern) } : {}))); });
+    return __assign({ type: 'point', data: data }, markConfig);
 };

package/esm/insight/chart/strategy/commonMarks/ruleMark.js

@@ -0,0 +1,2 @@
+import { __assign } from "tslib";
+export var ruleYMarkStrategy = function (y, config) { return (__assign({ type: 'ruleY', y: y }, config)); };

package/esm/insight/chart/strategy/viewSpec.js

@@ -1,16 +1,22 @@
-import { __assign } from "tslib";
 export var viewSpecStrategy = function (marks, insight) {
-    // majority insight pattern visualizes as 'pie', should not use y nice (G2 handle it as rescale y, the pie chart will be less than 100%)
-    var isMajorityPattern = insight.patterns.map(function (pattern) { return pattern.type; }).includes('majority');
-    var viewConfig = isMajorityPattern
-        ? { scale: { y: { nice: false } } }
-        : {
-            scale: { y: { nice: true } },
+    var _a, _b, _c, _d, _e;
+    var validMarks = marks.filter(Boolean);
+    var insightType = ((_a = insight.patterns[0]) !== null && _a !== void 0 ? _a : {}).type;
+    if (insightType === 'majority') {
+        return { coordinate: 'polar', marks: validMarks };
+    }
+    if (insightType === 'correlation') {
+        return {
+            coordinate: 'cartesian',
+            x: { field: (_b = insight.measures[0]) === null || _b === void 0 ? void 0 : _b.fieldName, type: 'value' },
+            y: { field: (_c = insight.measures[1]) === null || _c === void 0 ? void 0 : _c.fieldName, type: 'value' },
+            marks: validMarks,
         };
-    return __assign({ type: 'view', theme: 'dark', axis: {
-            x: { labelAutoHide: true, labelAutoRotate: false, title: false },
-            y: { title: false },
-        }, interaction: {
-            tooltip: { groupName: false },
-        }, legend: false, children: marks }, viewConfig);
+    }
+    return {
+        coordinate: 'cartesian',
+        x: { field: (_d = insight.dimensions[0]) === null || _d === void 0 ? void 0 : _d.fieldName, type: 'category' },
+        y: { field: (_e = insight.measures[0]) === null || _e === void 0 ? void 0 : _e.fieldName, type: 'value' },
+        marks: validMarks,
+    };
 };

package/esm/insight/chart/types.js

@@ -1 +1,8 @@
+/**
+ * Renderer-agnostic chart spec for insights.
+ *
+ * Strategies describe *what* to draw as a list of marks with semantic `role`s; renderers
+ * (e.g. `@formant/ava-react`, which compiles to ECharts) decide *how* it looks via a theme.
+ * No colors or renderer options live here, so a chart is restyled entirely by its theme.
+ */
 export {};

package/esm/insight/narrative/strategy/categoryOutlier.js

@@ -57,7 +57,7 @@ var CategoryOutlierNarrativeStrategy = /** @class */ (function (_super) {
                 template: '${.x}',
                 separator: getDefaultSeparator('zh-CN'),
                 variableMetaMap: variableMetaMap,
-                useVariable: 'paragraph',
+                useVariable: 'patterns',
             },
         ],
         'en-US': [
@@ -66,7 +66,7 @@ var CategoryOutlierNarrativeStrategy = /** @class */ (function (_super) {
                 template: '${.x}',
                 separator: getDefaultSeparator('en-US'),
                 variableMetaMap: variableMetaMap,
-                useVariable: 'paragraph',
+                useVariable: 'patterns',
             },
         ],
     };

package/esm/insight/narrative/strategy/timeSeriesOutlier.js

@@ -5,7 +5,7 @@ import { generateTextSpec } from '../../../ntv';
 import { InsightNarrativeStrategy } from './base';
 import { getDiffDesc } from './helpers';
 import { formatDateRange } from "little-date";
-import { formatDate } from 'date-fns';
+import { format } from 'date-fns';
 var variableMetaMap = {
     dateRange: {
         varType: 'time_desc',
@@ -54,7 +54,7 @@ var TimeSeriesOutlierNarrativeStrategy = /** @class */ (function (_super) {
                 outliers: patterns.map(function (point) {
                     var base = point.baselines[point.index];
                     var diff = point.y - base;
-                    return __assign(__assign({}, point), { base: base, diffDesc: getDiffDesc(diff, lang), x: formatDate(new Date(point.x), 'MMM d, yyyy'), diff: diff });
+                    return __assign(__assign({}, point), { base: base, diffDesc: getDiffDesc(diff, lang), x: format(new Date(point.x), 'MMM d, yyyy'), diff: diff });
                 }),
             },
         });

package/esm/insight/narrative/strategy/trend.js

@@ -50,7 +50,7 @@ var TrendNarrativeStrategy = /** @class */ (function (_super) {
         ],
         'en-US': [
             {
-                template: 'There is a signifcant ${trend} trend for ${measure} during ${dateRange} with a slope of ${slope}X.',
+                template: 'There is a significant ${trend} trend for ${measure} during ${dateRange} with a slope of ${slope}X.',
                 variableMetaMap: variableMetaMap,
             },
         ],

package/esm/insight/pipeline/specificInsight.js

@@ -28,12 +28,8 @@ export var getAnnotationSpec = function (insightInfo) {
     return (_b = insightType2AugmentedMarks[insightType]) === null || _b === void 0 ? void 0 : _b.call(insightType2AugmentedMarks, insightInfo);
 };
 export var getChartSpecWithoutAugmentedMarks = function (insightInfo, insightType) {
-    var chartMark = insight2ChartStrategy(__assign(__assign({}, insightInfo), (size(insightInfo.patterns) === 0
-        ? {
-            patterns: [{ type: insightType }],
-        }
-        : {})));
-    return viewSpecStrategy([chartMark], insightInfo);
+    var chartInsight = __assign(__assign({}, insightInfo), (size(insightInfo.patterns) === 0 ? { patterns: [{ type: insightType }] } : {}));
+    return viewSpecStrategy([insight2ChartStrategy(chartInsight)], chartInsight);
 };
 export var filterValidInsightInfoForAnnotationSpec = function (_a) {
     var _b = _a.patternInfos, patternInfos = _b === void 0 ? [] : _b, insightType = _a.insightType;

package/esm/insight/pipeline/visualize.js

@@ -30,10 +30,8 @@ export var generateHomogeneousInsightVisualizationSpec = function (insight, visu
     var schemas = [];
     patterns.forEach(function (pattern) {
         var insightType = pattern.insightType;
-        var chartSpec = {};
         schemas.push({
             patternType: insightType,
-            chartSpec: chartSpec,
             narrativeSpec: generateInsightNarrative(__assign(__assign({}, omit(insight, ['patterns'])), pattern), visualizationOptions),
         });
     });

package/lib/index.d.ts

@@ -5,6 +5,6 @@ export type { ChartId, Family, Purpose, CoordinateSystem, GraphicCategory, Shape
 export { analyzeField, Series, DataFrame, min, max, sum, mean, normalDistributionQuantile, tDistributionQuantile, distinct, valueMap, missing, valid, pearson, covariance, coefficientOfVariance, standardDeviation, variance, quantile, quartile, median, harmonicMean, geometricMean, pcorrtest, cdf, maxabs, } from './data';
 export type { FieldType, FieldInfo, StringFieldInfo, NumberFieldInfo, DateFieldInfo, NDArray, SeriesData, FrameData, Axis, Extra, FieldsInfo, } from './data';
 export { getInsights, generateInsightVisualizationSpec, insightPatternsExtractor, getSpecificInsight } from './insight';
-export type { Datum, DomainType, MeasureMethod, ImpactMeasureMethod, Aggregator, DataProperty, Measure, Dimension, Subspace, ImpactMeasure, SubjectInfo, InsightType, HomogeneousInsightType, PatternInfo, InsightVisualizationSpec, InsightInfo, InsightVisualizationOptions, InsightOptions, BasePatternInfo, HomogeneousPatternInfo, PointPatternInfo, CategoryOutlierInfo, TimeSeriesOutlierInfo, ChangePointInfo, MajorityInfo, LinearRegressionResult, LowVarianceInfo, CorrelationInfo, InsightsResult, InsightExtractorProps, SpecificInsightProps, AugmentedMarks, } from './insight';
+export type { Datum, DomainType, MeasureMethod, ImpactMeasureMethod, Aggregator, DataProperty, Measure, Dimension, Subspace, ImpactMeasure, SubjectInfo, InsightType, HomogeneousInsightType, PatternInfo, InsightVisualizationSpec, InsightInfo, InsightVisualizationOptions, InsightOptions, BasePatternInfo, HomogeneousPatternInfo, PointPatternInfo, CategoryOutlierInfo, TimeSeriesOutlierInfo, ChangePointInfo, MajorityInfo, LinearRegressionResult, LowVarianceInfo, CorrelationInfo, InsightsResult, InsightExtractorProps, SpecificInsightProps, AugmentedMarks, InsightChartSpec, InsightChartMark, InsightChartAxis, InsightChartPoint, InsightChartValue, InsightMarkRole, InsightLineMark, InsightBarMark, InsightPointMark, InsightAreaMark, InsightRuleXMark, InsightRuleYMark, InsightArcMark, } from './insight';
 export { generateTextSpec, isCustomSection, isStandardSection, isCustomParagraph, isTextParagraph, isBulletParagraph, getHeadingWeight, isHeadingParagraph, isDividerParagraph, isEntityPhrase, isImagePhrase, isCustomPhrase, isTextPhrase, isEntityType, isEscapePhrase, isFormulaPhrase, ENTITY_TYPES, } from './ntv';
 export * from './ntv/types';

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

@@ -1,14 +1,5 @@
-import { ChartType, InsightType } from '../types';
-export declare const INSIGHT_COLOR_PLATTE: Record<string, string>;
-export declare const BOLD_FONT_WEIGHT = 500;
-export declare const TEXT_STYLE: {
-    textAlign: string;
-    fill: string;
-    fontFamily: string;
-    opacity: number;
-};
-export declare const ChartTypeMap: Record<InsightType, ChartType>;
-export declare const PIE_RADIUS_STYLE: {
+/** pie radii as fractions of the available radius */
+export declare const PIE_RADIUS: {
     innerRadius: number;
     outerRadius: number;
 };