@formant/ava 3.4.1-formant

package/esm/data/statistics/vector.js

@@ -0,0 +1,67 @@
+/** operation of vector or matrix */
+export var vectorAdd = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    return x.map(function (xi, i) { return xi + y[i]; });
+};
+export var vectorSubtract = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    return x.map(function (xi, i) { return xi - y[i]; });
+};
+export var vectorInnerProduct = function (x, y) {
+    if (x.length !== y.length)
+        return null;
+    var result = 0;
+    x.forEach(function (xi, i) {
+        result += xi * y[i];
+    });
+    return result;
+};
+export var matrixTranspose = function (x) {
+    var result = [];
+    var _loop_1 = function (j) {
+        result.push(x.map(function (xi) { return xi[j]; }));
+    };
+    for (var j = 0; j < x[0].length; j += 1) {
+        _loop_1(j);
+    }
+    return result;
+};
+export var matrixMultiply = function (x, y) {
+    var _a;
+    if (((_a = x[0]) === null || _a === void 0 ? void 0 : _a.length) !== y.length)
+        return null;
+    var result = [];
+    var yT = matrixTranspose(y);
+    x.forEach(function (xi) { return result.push(yT.map(function (yj) { return vectorInnerProduct(xi, yj); })); });
+    return result;
+};
+export var multiMatrixMultiply = function (matrixSet) {
+    var result = matrixSet[0];
+    for (var i = 1; i < matrixSet.length; i += 1) {
+        result = matrixMultiply(result, matrixSet[i]);
+    }
+    return result;
+};
+/**
+ * Constructs a diagonal matrix where the values of the main diagonal are the values of the given vector
+ */
+export var constructDiagonalMatrix = function (diagonalVector) {
+    return diagonalVector.map(function (diagonalValue, i) {
+        // ith row
+        var row = Array(diagonalVector.length).fill(0);
+        row[i] = diagonalValue;
+        return row;
+    });
+};
+/**
+ * Calculate the inverse matrix for second order matrix
+ * */
+export var inverseSecondOrderMatrix = function (matrix) {
+    var determinant = matrix[0][0] * matrix[1][1] - matrix[0][1] * matrix[1][0];
+    return [
+        [matrix[1][1] / determinant, -matrix[0][1] / determinant],
+        [-matrix[1][0] / determinant, matrix[0][0] / determinant],
+    ];
+};

package/esm/data/statistics/window.js

@@ -0,0 +1,55 @@
+import { mean } from 'lodash';
+import { SIGNIFICANCE_BENCHMARK } from '../../insight/constant';
+import { calculatePValue } from '../../insight/insights/util';
+var DEFAULT_WINDOW_SIZE = 4;
+/**
+ * Window-based change point detection
+ */
+export function windowBasedMean(data, params) {
+    var len = data === null || data === void 0 ? void 0 : data.length;
+    var K = (params === null || params === void 0 ? void 0 : params.windowSize) || DEFAULT_WINDOW_SIZE;
+    if (len <= 2 * K + 3)
+        return [];
+    var significanceLimit = (params === null || params === void 0 ? void 0 : params.significanceLimit) || SIGNIFICANCE_BENCHMARK;
+    var diff = Array(len).fill(0);
+    for (var i = K; i <= len - K; i += 1) {
+        var meanLeft = mean(data.slice(i - K, i));
+        var meanRight = mean(data.slice(i, i + K));
+        diff[i] = Math.abs(meanLeft - meanRight);
+    }
+    var differences = diff.slice(K, len - K + 1);
+    var sorted = differences.sort(function (a, b) { return b - a; });
+    var result = [];
+    var _loop_1 = function (i) {
+        var difference = sorted[i];
+        var index = diff.findIndex(function (item) { return item === difference; });
+        var significance = 1 - calculatePValue(differences, difference);
+        if (significance >= significanceLimit) {
+            result.push({
+                index: index,
+                significance: significance,
+            });
+        }
+    };
+    for (var i = 0; i < sorted.length; i += 1) {
+        _loop_1(i);
+    }
+    return result;
+}
+/**
+ * Window-based change point test
+ */
+export function calcPValue(data, index, window) {
+    var len = data === null || data === void 0 ? void 0 : data.length;
+    var K = window || DEFAULT_WINDOW_SIZE;
+    if (len <= 2 * K + 3)
+        return 0;
+    var diff = Array(len).fill(0);
+    for (var i = K; i <= len - K; i += 1) {
+        var meanLeft = mean(data.slice(i - K, i));
+        var meanRight = mean(data.slice(i, i + K));
+        diff[i] = Math.abs(meanLeft - meanRight);
+    }
+    var p = calculatePValue(diff.slice(K, len - K + 1), diff[index]);
+    return p;
+}

package/esm/data/types.js

@@ -0,0 +1,2 @@
+export * from './analysis/types';
+export * from './dataset/types';

package/esm/data/utils/common.js

@@ -0,0 +1,58 @@
+import { __read, __spreadArray } from "tslib";
+import { isArray } from './isType';
+/**
+ * Return an array with unique elements
+ * @param value
+ */
+export function unique(value) {
+    return Array.from(new Set(value));
+}
+/**
+ * Generate an array from 0 to number.
+ * @param number
+ */
+export function range(number) {
+    return __spreadArray([], __read(Array(number).keys()), false);
+}
+/** Generate an array with all 1 elements */
+export function nOnes(n) {
+    return Array(n).fill(1);
+}
+/** Generate an array with all 0 elements */
+export function nZeros(n) {
+    return Array(n).fill(0);
+}
+/**
+ * assert
+ * @param condition
+ * @param errorMessage
+ */
+export function assert(condition, errorMessage) {
+    if (!condition)
+        throw new Error(errorMessage);
+}
+/**
+ * Check parent-child relationship. A child has only one parent, but a parent can have more children.
+ * @param parent
+ * @param child
+ */
+export function isParentChild(parent, child) {
+    if (!isArray(parent) ||
+        parent.length === 0 ||
+        !isArray(child) ||
+        child.length === 0 ||
+        parent.length !== child.length)
+        return false;
+    var record = {};
+    for (var i = 0; i < child.length; i += 1) {
+        var c = child[i];
+        var p = parent[i];
+        if (!record[c]) {
+            record[c] = p;
+        }
+        else if (record[c] !== p) {
+            return false;
+        }
+    }
+    return true;
+}

package/esm/data/utils/index.js

@@ -0,0 +1,5 @@
+/*
+ * Utils used internally by ava.
+ */
+export * from './common';
+export * from './isType';

package/esm/data/utils/isType/constants.js

@@ -0,0 +1,24 @@
+export var SPECIAL_BOOLEANS = [
+    [true, false],
+    [0, 1],
+    ['true', 'false'],
+    ['Yes', 'No'],
+    ['True', 'False'],
+    ['0', '1'],
+    ['是', '否'],
+];
+// For isDateString.ts
+export var DELIMITER = '([-_./\\s])';
+export var YEAR = '(?<year>(18|19|20)\\d{2})';
+export var MONTH = '(?<month>0?[1-9]|1[012])';
+export var DAY = '(?<day>0?[1-9]|[12]\\d|3[01])';
+export var WEEK = '(?<week>[0-4]\\d|5[0-2])';
+export var WEEKDAY = '(?<weekday>[1-7])';
+export var BASE_HOUR = '(0?\\d|1\\d|2[0-4])';
+export var BASE_MINUTE = '(0?\\d|[012345]\\d)';
+export var HOUR = "(?<hour>".concat(BASE_MINUTE, ")");
+export var MINUTE = "(?<minute>".concat(BASE_MINUTE, ")");
+export var SECOND = "(?<second>".concat(BASE_MINUTE, ")");
+export var MILLISECOND = '(?<millisecond>\\d{1,4})';
+export var YEARDAY = '(?<yearDay>(([0-2]\\d|3[0-5])\\d)|36[0-6])';
+export var OFFSET = "(?<offset>Z|[+-]".concat(BASE_HOUR, "(:").concat(BASE_MINUTE, ")?)");

package/esm/data/utils/isType/index.js

@@ -0,0 +1,2 @@
+export * from './isType';
+export * from './isDateString';

package/esm/data/utils/isType/isDateString.js

@@ -0,0 +1,104 @@
+/*
+ * Check whether the string is a date.
+ */
+import { __read, __spreadArray } from "tslib";
+import { DAY, DELIMITER, HOUR, MILLISECOND, MINUTE, MONTH, OFFSET, SECOND, WEEK, WEEKDAY, YEAR, YEARDAY, } from './constants';
+import { isString } from './isType';
+/**
+ * Get ISO 8601 date regular expression string array
+ * Reference: https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+ * @param strict Require delimiter or not
+ */
+export function getIsoDatePatterns(strict) {
+    if (strict === void 0) { strict = true; }
+    return [
+        // 1991
+        "".concat(YEAR),
+        // 1999-W12-7
+        "".concat(YEAR).concat(DELIMITER).concat(strict ? '' : '?', "W").concat(WEEK, "(").concat(DELIMITER).concat(strict ? '' : '?').concat(WEEKDAY, ")?"),
+        // 12-22-1999
+        "".concat(MONTH).concat(DELIMITER).concat(strict ? '' : '?').concat(DAY).concat(DELIMITER).concat(strict ? '' : '?').concat(YEAR),
+        // 1999-12-22 19991222
+        "".concat(YEAR).concat(DELIMITER).concat(strict ? '' : '?').concat(MONTH).concat(DELIMITER).concat(strict ? '' : '?').concat(DAY),
+        // 1999-12
+        "".concat(YEAR).concat(DELIMITER).concat(strict ? '' : '?').concat(MONTH),
+        // 1999-200
+        "".concat(YEAR).concat(DELIMITER).concat(strict ? '' : '?').concat(YEARDAY),
+    ];
+}
+/**
+ * Get ISO 8601 time regular expression string array
+ * Reference: https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+ * @param strict Require DELIMITER or not
+ */
+export function getIsoTimePatterns(strict) {
+    if (strict === void 0) { strict = true; }
+    return [
+        // 23:20:20Z 23:20:20+08:00 23:20:20-08:00
+        "".concat(HOUR, ":").concat(strict ? '' : '?').concat(MINUTE, ":").concat(strict ? '' : '?').concat(SECOND, "([.,]").concat(MILLISECOND, ")?").concat(OFFSET, "?"),
+        // 23:20+08
+        "".concat(HOUR, ":").concat(strict ? '' : '?').concat(MINUTE, "?").concat(OFFSET),
+    ];
+}
+var getIsoDateAndTimeRegs = function (strictDatePattern) {
+    var isoDatePatterns = getIsoDatePatterns(strictDatePattern);
+    var isoTimePatterns = getIsoTimePatterns(strictDatePattern);
+    var isoDateAndTimePatterns = __spreadArray(__spreadArray([], __read(isoDatePatterns), false), __read(isoTimePatterns), false);
+    isoDatePatterns.forEach(function (d) {
+        isoTimePatterns.forEach(function (t) {
+            isoDateAndTimePatterns.push("".concat(d, "[T\\s]").concat(t));
+        });
+    });
+    return isoDateAndTimePatterns.map(function (pattern) {
+        return new RegExp("^".concat(pattern, "$"));
+    });
+};
+export function isDateString(value, strictDatePattern) {
+    if (isString(value)) {
+        var isoDateAndTimeRegs = getIsoDateAndTimeRegs(strictDatePattern);
+        for (var i = 0; i < isoDateAndTimeRegs.length; i += 1) {
+            var reg = isoDateAndTimeRegs[i];
+            if (reg.test(value.trim())) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** parse ISO 8601 date string to standard Date type, if month and date is missing, will use new Date(01-01)
+ * Reference: https://www.cl.cam.ac.uk/~mgk25/iso-time.html
+ * 将日期字符串转为标准 Date 类型，如果没有月日，只有时间信息，会默认为 01-01
+ */
+export function parseIsoDateString(value, strictDatePattern) {
+    if (strictDatePattern === void 0) { strictDatePattern = false; }
+    var isoDateAndTimeRegs = getIsoDateAndTimeRegs(strictDatePattern);
+    for (var i = 0; i < isoDateAndTimeRegs.length; i += 1) {
+        var reg = isoDateAndTimeRegs[i];
+        if (reg.test(value.trim())) {
+            var matches = value.trim().match(reg);
+            if (matches.groups) {
+                var _a = matches.groups || {}, year = _a.year, month = _a.month, day = _a.day, week = _a.week, weekday = _a.weekday, hour = _a.hour, minute = _a.minute, second = _a.second, millisecond = _a.millisecond, yearDay = _a.yearDay, offset = _a.offset;
+                var yearNum = parseInt(year, 10);
+                if (yearDay) {
+                    return new Date(yearNum, 0, parseInt(yearDay, 10));
+                }
+                if (week) {
+                    var weekNum = parseInt(week, 10);
+                    var weekDayNum = weekday ? parseInt(weekday, 10) : 1;
+                    var firstDayOfYear = new Date(yearNum, 0, 1);
+                    // 给定年份的第一天是周几
+                    var firstDayOfYearDayOfWeek = firstDayOfYear.getDay() === 0 ? 7 : firstDayOfYear.getDay();
+                    // 计算第一周的第一天相对 firstDayOfYear 的偏移量
+                    var firstWeekStartDayOffset = firstDayOfYearDayOfWeek === 1 ? 1 : 1 - firstDayOfYearDayOfWeek;
+                    // 目标日期偏移量
+                    var targetDateOffset = (weekNum - 1) * 7 + (weekDayNum + firstWeekStartDayOffset);
+                    return new Date(yearNum, 0, targetDateOffset);
+                }
+                var formattedDateString = [year, month !== null && month !== void 0 ? month : '01', day !== null && day !== void 0 ? day : '01'].join('-');
+                var formattedTimeString = "".concat([hour !== null && hour !== void 0 ? hour : '00', minute !== null && minute !== void 0 ? minute : '00', second !== null && second !== void 0 ? second : '00'].join(':'), ".").concat(millisecond !== null && millisecond !== void 0 ? millisecond : '000').concat(offset !== null && offset !== void 0 ? offset : '');
+                return new Date("".concat(formattedDateString, " ").concat(formattedTimeString));
+            }
+        }
+    }
+    return null;
+}

package/esm/data/utils/isType/isType.js

@@ -0,0 +1,78 @@
+import { SPECIAL_BOOLEANS } from './constants';
+export function isNil(value) {
+    return value === null || value === undefined || value === '' || Number.isNaN(value) || value === 'null';
+}
+export function isString(value) {
+    return typeof value === 'string';
+}
+export function isNumber(value) {
+    if (typeof value === 'number')
+        return true;
+    return false;
+}
+export function isNumberString(value) {
+    if (isString(value)) {
+        var hasDot = false;
+        var tempValue = value;
+        if (/^[+-]/.test(tempValue)) {
+            tempValue = tempValue.slice(1);
+        }
+        for (var i = 0; i < tempValue.length; i += 1) {
+            var char = tempValue[i];
+            if (char === '.') {
+                if (hasDot === false) {
+                    hasDot = true;
+                }
+                else {
+                    return false;
+                }
+            }
+            if (char !== '.' && !/[0-9]/.test(char)) {
+                return false;
+            }
+        }
+        return tempValue.trim() !== '';
+    }
+    return false;
+}
+export function isInteger(value) {
+    if (typeof value === 'number')
+        return Number.isInteger(value);
+    return false;
+}
+export function isIntegerString(value) {
+    if (isString(value) && isNumberString(value))
+        return !value.includes('.');
+    return false;
+}
+export function isFloat(value) {
+    if (typeof value === 'number')
+        return !Number.isNaN(value) && !Number.isInteger(value);
+    return false;
+}
+export function isFloatString(value) {
+    if (isString(value) && isNumberString(value))
+        return value.includes('.');
+    return false;
+}
+export function isDate(value) {
+    if (value && Object.getPrototypeOf(value) === Date.prototype)
+        return true;
+    return false;
+}
+export function isBoolean(value, checkSpecialBoolean) {
+    return checkSpecialBoolean
+        ? SPECIAL_BOOLEANS.some(function (list) {
+            return value.every(function (item) { return list.includes(item); });
+        })
+        : typeof value === 'boolean';
+}
+export function isObject(value) {
+    return value && Object.getPrototypeOf(value) === Object.prototype;
+}
+export function isArray(value) {
+    return Array.isArray(value);
+}
+export function isBasicType(value) {
+    return !isArray(value) && !isObject(value);
+}

package/esm/index.js

@@ -0,0 +1,11 @@
+/* advisor */
+export { Advisor } from './advisor';
+/* CKB */
+export { ckb, ckbDict, CHANNELS, CHART_IDS, COORDINATE_SYSTEMS, FAMILIES, GRAPHIC_CATEGORIES, LEVEL_OF_MEASUREMENTS, PURPOSES, RECOMMEND_RATINGS, SHAPES, } from './ckb';
+/* data */
+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';
+/* insight */
+export { getInsights, generateInsightVisualizationSpec, insightPatternsExtractor, getSpecificInsight } from './insight';
+/* NTV (Narrative Text Vis) */
+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/esm/insight/algorithms/base/compare.js

@@ -0,0 +1,40 @@
+/**
+ * lodash sortby asc function
+ * @param left unknown
+ * @param right unknown
+ * @returns number
+ */
+export function ascending(left, right) {
+    var leftIsNull = left === null || left === undefined;
+    var rightIsNull = right === null || right === undefined;
+    if (leftIsNull && rightIsNull) {
+        return 0;
+    }
+    if (leftIsNull) {
+        return 1;
+    }
+    if (rightIsNull) {
+        return -1;
+    }
+    return left - right;
+}
+/**
+ * lodash sortby desc function
+ * @param left any
+ * @param right any
+ * @returns number
+ */
+export function descending(left, right) {
+    var leftIsNull = left === null || left === undefined;
+    var rightIsNull = right === null || right === undefined;
+    if (leftIsNull && rightIsNull) {
+        return 0;
+    }
+    if (leftIsNull) {
+        return 1;
+    }
+    if (rightIsNull) {
+        return -1;
+    }
+    return right - left;
+}

package/esm/insight/algorithms/categoryOutlier.js

@@ -0,0 +1,4 @@
+import { IQR } from '../../data/statistics/IQR';
+export var categoryOutlier = {
+    IQR: IQR,
+};

package/esm/insight/algorithms/changePoint.js

@@ -0,0 +1,10 @@
+import { bayesian } from '../../data/statistics/bayesian';
+import { windowBasedMean } from '../../data/statistics/window';
+import { pettittTest } from '../../data/statistics/pettitt-test';
+import { buishandUTest } from '../../data/statistics/buishand-u';
+export var changePoint = {
+    Bayesian: bayesian,
+    Window: windowBasedMean,
+    PettittTest: pettittTest,
+    BuishandUTest: buishandUTest,
+};

package/esm/insight/algorithms/index.js

@@ -0,0 +1,3 @@
+export * from './categoryOutlier';
+export * from './trendDirection';
+export * from './changePoint';

package/esm/insight/algorithms/trendDirection.js

@@ -0,0 +1,4 @@
+import { mkTest } from '../../data/statistics/mannkendall-test';
+export var trendDirection = {
+    mkTest: mkTest,
+};

package/esm/insight/chart/constants.js

@@ -0,0 +1,25 @@
+export var INSIGHT_COLOR_PLATTE = {
+    highlight: '#E09322',
+    outlier: '#CB5140',
+    font: '#2C3542',
+    defaultPointColor: '#fff',
+};
+export var BOLD_FONT_WEIGHT = 500;
+export var TEXT_STYLE = {
+    textAlign: 'center',
+    fill: INSIGHT_COLOR_PLATTE.font,
+    opacity: 0.65,
+};
+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 = {
+    innerRadius: 0.25,
+    outerRadius: 0.8,
+};

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

@@ -0,0 +1,70 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import { INSIGHT_COLOR_PLATTE } from '../constants';
+export 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' ? INSIGHT_COLOR_PLATTE.highlight : 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, __spreadArray([], __read(circles), false));
+    }
+    return annotations;
+}
+export 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 = __assign(__assign({}, plotSchema), { annotations: annotationConfig });
+    return chartSchema;
+}

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

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

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

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

package/esm/insight/chart/index.js

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

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

@@ -0,0 +1,30 @@
+import { __read, __spreadArray } from "tslib";
+import { size } from 'lodash';
+import { dataFormat } from '../../../../utils';
+import { BOLD_FONT_WEIGHT } from '../../constants';
+import { insight2ChartStrategy } from '../chart';
+import { textMarkStrategy, intervalMarkStrategy } 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]);
+        var textMark = textMarkStrategy([pattern], {
+            style: { fontWeight: BOLD_FONT_WEIGHT, dy: -8 },
+            formatter: dataFormat,
+        });
+        categoryOutlierMarks.push({
+            categoryOutlier: [rectMark, textMark],
+        });
+    });
+    return categoryOutlierMarks;
+};
+export var categoryOutlierStrategy = function (insight) {
+    var chart = insight2ChartStrategy(insight);
+    var categoryOutlierMarks = categoryOutlierAugmentedMarksStrategy(insight);
+    var marks = augmentedMarks2Marks(categoryOutlierMarks);
+    return __spreadArray([chart], __read(marks), false);
+};