@formant/ava 3.4.1-formant

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

@@ -0,0 +1,42 @@
+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 { 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: '#2C3542',
+                startMarkerFillOpacity: 0.65,
+            },
+        });
+        changePointMarks.push({
+            changePoint: [pointMark, textMark],
+        });
+    });
+    return changePointMarks;
+};
+export var changePointStrategy = function (insight) {
+    var chart = insight2ChartStrategy(insight);
+    var changePointMarks = changePointAugmentedMarksStrategy(insight);
+    var marks = augmentedMarks2Marks(changePointMarks);
+    return __spreadArray([chart], __read(marks), false);
+};

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

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

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

@@ -0,0 +1,5 @@
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+export var homogeneousStrategy = function (_insight) {
+    // colorField: string
+    return {};
+};

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

@@ -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/esm/insight/chart/strategy/augmentedMarks/lowVariance.js

@@ -0,0 +1,23 @@
+import { __read, __spreadArray } from "tslib";
+import { lineMarkStrategy } 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 marks;
+};
+export var lowVarianceStrategy = function (insight) {
+    var chartMark = insight2ChartStrategy(insight);
+    var lowVarianceMarks = lowVarianceAugmentedMarkStrategy(insight);
+    var marks = augmentedMarks2Marks(lowVarianceMarks);
+    return __spreadArray([chartMark], __read(marks), false);
+};

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

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

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

@@ -0,0 +1,82 @@
+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' }],
+        },
+    });
+    return [
+        {
+            trendLine: [baselineMark],
+            anomalyArea: [intervalMark],
+            outliers: [outlierMark],
+        },
+    ];
+};
+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;
+    return __spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read(anomalyArea), false), __read(trendLine), false), [chartMark], false), __read(outliers), false);
+};

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

@@ -0,0 +1,26 @@
+import { __read, __spreadArray } from "tslib";
+import { lineMarkStrategy } from '../commonMarks';
+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)) });
+    return [
+        {
+            trendLine: [regressionLineMark],
+        },
+    ];
+};
+export var trendStrategy = function (insight) {
+    var _a, _b;
+    var chart = insight2ChartStrategy(insight);
+    var trendMarks = trendAugmentedMarksStrategy(insight);
+    return __spreadArray([chart], __read(((_b = (_a = trendMarks[0]) === null || _a === void 0 ? void 0 : _a.trendLine) !== null && _b !== void 0 ? _b : [])), false);
+};

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

@@ -0,0 +1,45 @@
+import { __assign } from "tslib";
+import { PIE_RADIUS_STYLE } from '../constants';
+export 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 __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 }],
+            } });
+    }
+    // line
+    if (insightType === 'trend' || insightType === 'time_series_outlier' || insightType === 'change_point') {
+        return __assign(__assign({}, commonSpec), { type: 'line', style: {
+                lineWidth: 2,
+            } });
+    }
+    // bar
+    if (insightType === 'category_outlier' || insightType === 'low_variance') {
+        return __assign(__assign({}, commonSpec), { type: 'interval' });
+    }
+    // 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,
+            } });
+    }
+    return null;
+};

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

@@ -0,0 +1,12 @@
+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;
+};

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

@@ -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/esm/insight/chart/strategy/commonMarks/intervalMark.js

@@ -0,0 +1,14 @@
+import { __assign } from "tslib";
+import { INSIGHT_COLOR_PLATTE } from '../../constants';
+/** get mark for point patterns, the patterns should have same dimension and measure */
+export var intervalMarkStrategy = function (patterns, config) {
+    var data = patterns.map(function (_a) {
+        var x = _a.x, y = _a.y;
+        return ({ x: x, y: y });
+    });
+    var intervalMark = __assign(__assign({ type: 'interval', data: data, encode: {
+            x: 'x',
+            y: 'y',
+        } }, config), { style: __assign(__assign({}, config === null || config === void 0 ? void 0 : config.style), { fill: INSIGHT_COLOR_PLATTE.outlier }) });
+    return intervalMark;
+};

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

@@ -0,0 +1,34 @@
+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;
+};

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

@@ -0,0 +1,17 @@
+import { __assign } 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 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;
+};

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

@@ -0,0 +1,28 @@
+import { __assign } from "tslib";
+import { isFunction } from 'lodash';
+import { TEXT_STYLE } from '../../constants';
+/** get mark for point patterns, the patterns should have same dimension and measure */
+export var textMarkStrategy = function (patterns, textConfig) {
+    var _a = textConfig || {}, style = _a.style, label = _a.label, formatter = _a.formatter;
+    var _b = patterns[0], measure = _b.measure, dimension = _b.dimension;
+    var data = patterns.map(function (pattern) {
+        var _a;
+        var customLabel = isFunction(label) ? label(pattern) : label;
+        var value = isFunction(formatter) ? formatter(pattern.y) : pattern.y;
+        return _a = {},
+            _a[dimension] = pattern.x,
+            _a[measure] = pattern.y,
+            _a.label = customLabel !== null && customLabel !== void 0 ? customLabel : "".concat(pattern.x, "\n").concat(value),
+            _a;
+    });
+    return {
+        type: 'text',
+        data: data,
+        encode: {
+            x: dimension,
+            y: measure,
+            text: 'label',
+        },
+        style: __assign(__assign({}, TEXT_STYLE), style),
+    };
+};

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

@@ -0,0 +1,4 @@
+export { insight2ChartStrategy } from './chart';
+export { viewSpecStrategy } from './viewSpec';
+export * from './commonMarks';
+export * from './augmentedMarks';

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

@@ -0,0 +1,16 @@
+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 } },
+        };
+    return __assign({ type: 'view', theme: 'classic', axis: {
+            x: { labelAutoHide: true, labelAutoRotate: false, title: false },
+            y: { title: false },
+        }, interaction: {
+            tooltip: { groupName: false },
+        }, legend: false, children: marks }, viewConfig);
+};

package/esm/insight/chart/types.js

@@ -0,0 +1 @@
+export {};

package/esm/insight/chart/utils.js

@@ -0,0 +1,4 @@
+import { flattenDeep, map } from 'lodash';
+export var augmentedMarks2Marks = function (augmentedMarks) {
+    return flattenDeep(map(augmentedMarks, function (augmentedMark) { return Object.values(augmentedMark); }));
+};

package/esm/insight/constant.js

@@ -0,0 +1,21 @@
+// Should be confidence level. Is the SIGNIFICANCE_BENCHMARK naming correct? by @pddpd
+export var SIGNIFICANCE_BENCHMARK = 0.95;
+export var SIGNIFICANCE_LEVEL = 0.05;
+export var INSIGHT_SCORE_BENCHMARK = 0.01;
+export var IMPACT_SCORE_WEIGHT = 0.2;
+export var INSIGHT_DEFAULT_LIMIT = 20;
+export var IQR_K = 1.5;
+export var LOWESS_N_STEPS = 2;
+export var PATTERN_TYPES = [
+    'category_outlier',
+    'trend',
+    'change_point',
+    'time_series_outlier',
+    'majority',
+    'low_variance',
+    'correlation',
+];
+export var HOMOGENEOUS_PATTERN_TYPES = ['commonness', 'exception'];
+export var VERIFICATION_FAILURE_INFO = 'The input does not meet the requirements.';
+export var NO_PATTERN_INFO = 'No insights were found at the specified significance threshold.';
+export var CHANGE_POINT_SIGNIFICANCE_BENCHMARK = 0.15;

package/esm/insight/index.js

@@ -0,0 +1,5 @@
+export { getInsights } from './pipeline';
+export { insightPatternsExtractor } from './insights';
+export { generateInsightVisualizationSpec } from './pipeline/visualize';
+export * from './types';
+export { getSpecificInsight } from './pipeline/specificInsight';

package/esm/insight/insights/checkers.js

@@ -0,0 +1,97 @@
+import { intersection } from 'lodash';
+var fieldsQuantityChecker = function (subjectInfo, dimensionsQuantity, measuresQuantity) {
+    var dimensions = subjectInfo.dimensions, measures = subjectInfo.measures;
+    if (dimensions.length === dimensionsQuantity && measures.length === measuresQuantity)
+        return true;
+    return false;
+};
+var generalCheckerFor1M1D = function (_a) {
+    var _b, _c, _d, _e;
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap, lom = _a.lom;
+    var dimensions = subjectInfo.dimensions;
+    // check data length
+    if ((data === null || data === void 0 ? void 0 : data.length) < 3)
+        return 'The data length is less than 3. ';
+    // check field quantity
+    if (!fieldsQuantityChecker(subjectInfo, 1, 1))
+        return 'The length of the measure or dimension is not 1. ';
+    // check dimension type
+    if (Array.isArray(lom)
+        ? !((_c = intersection((_b = fieldPropsMap[dimensions[0]]) === null || _b === void 0 ? void 0 : _b.levelOfMeasurements, lom)) === null || _c === void 0 ? void 0 : _c.length)
+        : !((_e = (_d = fieldPropsMap[dimensions[0]]) === null || _d === void 0 ? void 0 : _d.levelOfMeasurements) === null || _e === void 0 ? void 0 : _e.includes(lom)))
+        return "The type of the dimension field is not included in the option ".concat(Array.isArray(lom) ? lom : [lom], ". ");
+    return true;
+};
+export var trendChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+export var categoryOutlierChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: ['Nominal', 'Discrete', 'Ordinal'] });
+};
+export var changePointChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+export var timeSeriesChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+export var majorityChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    var checkerFor1M1D = generalCheckerFor1M1D({
+        data: data,
+        subjectInfo: subjectInfo,
+        fieldPropsMap: fieldPropsMap,
+        lom: ['Nominal', 'Discrete', 'Ordinal', 'Time'],
+    });
+    if (checkerFor1M1D !== true)
+        return checkerFor1M1D;
+    var measures = subjectInfo.measures;
+    if (!['count', 'sum'].includes(measures[0].method))
+        return 'Measure is not aggregated in sum or count mode. ';
+    return true;
+};
+export var lowVarianceChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    var checkerFor1M1D = generalCheckerFor1M1D({
+        data: data,
+        subjectInfo: subjectInfo,
+        fieldPropsMap: fieldPropsMap,
+        lom: ['Nominal', 'Discrete', 'Ordinal'],
+    });
+    if (checkerFor1M1D !== true)
+        return checkerFor1M1D;
+    var measures = subjectInfo.measures;
+    // 低方差检验使用变异系数 sigma/mean 作为检验统计量，要求均值不能为0
+    if (['float', 'integer'].includes(fieldPropsMap[measures[0].fieldName].recommendation)) {
+        if (fieldPropsMap[measures[0].fieldName].mean !== 0)
+            return true;
+        return 'The low variance test uses the coefficient of variation sigma/mean as the test statistic and requires that the mean cannot be 0. ';
+    }
+    return 'The recommended data type of measure is not float or integer. ';
+};
+export var correlationChecker = function (_a) {
+    var _b, _c;
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    var measures = subjectInfo.measures;
+    // check data length
+    if ((data === null || data === void 0 ? void 0 : data.length) < 3)
+        return 'The data length is less than 3. ';
+    // check field quantity
+    if (measures.length !== 2)
+        return 'The length of the measure or dimension is not 2. ';
+    if (!((_b = fieldPropsMap[measures[0].fieldName].levelOfMeasurements) === null || _b === void 0 ? void 0 : _b.includes('Continuous')) ||
+        !((_c = fieldPropsMap[measures[1].fieldName].levelOfMeasurements) === null || _c === void 0 ? void 0 : _c.includes('Continuous')))
+        return 'Level of measurement is not continuous. ';
+    return true;
+};
+export var ExtractorCheckers = {
+    category_outlier: categoryOutlierChecker,
+    trend: trendChecker,
+    change_point: changePointChecker,
+    time_series_outlier: timeSeriesChecker,
+    low_variance: lowVarianceChecker,
+    correlation: correlationChecker,
+};

package/esm/insight/insights/extractors/categoryOutlier.js

@@ -0,0 +1,90 @@
+import { __read, __spreadArray } from "tslib";
+import { get, isNil, isString, orderBy } from 'lodash';
+import { distinct, mean } from '../../../data';
+import { categoryOutlier } from '../../algorithms';
+import { IQR_K, SIGNIFICANCE_BENCHMARK } from '../../constant';
+import { calculatePValue, calculateOutlierThresholds, preValidation, getAlgorithmCommonInput, getNonSignificantInsight, } from '../util';
+export var findOutliers = function (values, outlierParameter) {
+    var _a = outlierParameter || {}, method = _a.method, iqrK = _a.iqrK, _b = _a.confidenceInterval, confidenceInterval = _b === void 0 ? SIGNIFICANCE_BENCHMARK : _b;
+    var outliers = [];
+    var thresholds = [];
+    var candidates = values.map(function (item, index) {
+        return { index: index, value: item };
+    });
+    if (method !== 'p-value') {
+        var IQRResult = categoryOutlier.IQR(values, { k: iqrK !== null && iqrK !== void 0 ? iqrK : IQR_K });
+        var lowerOutlierIndexes = IQRResult.lower.indexes;
+        var upperOutlierIndexes = IQRResult.upper.indexes;
+        __spreadArray(__spreadArray([], __read(lowerOutlierIndexes), false), __read(upperOutlierIndexes), false).forEach(function (index) {
+            var value = values[index];
+            var pValue = (candidates.findIndex(function (item) { return item.value === value; }) + 1) / values.length;
+            // two-sided
+            var significance = pValue > 0.5 ? pValue : 1 - pValue;
+            outliers.push({
+                index: index,
+                value: value,
+                significance: significance,
+            });
+        });
+        thresholds.push(IQRResult.lower.threshold, IQRResult.upper.threshold);
+    }
+    else {
+        var sortedCandidates = orderBy(candidates, function (item) { return Math.abs(mean(values) - item.value); }, ['desc']);
+        thresholds.push.apply(thresholds, __spreadArray([], __read(calculateOutlierThresholds(values, confidenceInterval, 'two-sided')), false));
+        for (var i = 0; i < sortedCandidates.length; i += 1) {
+            var candidate = sortedCandidates[i];
+            var value = candidate.value, index = candidate.index;
+            var pValue = calculatePValue(values, value, 'two-sided');
+            var significance = 1 - pValue;
+            if (significance < confidenceInterval) {
+                break;
+            }
+            outliers.push({
+                index: index,
+                value: value,
+                significance: significance,
+            });
+        }
+    }
+    return { outliers: outliers, thresholds: thresholds };
+};
+export var getCategoryOutlierInfo = function (props) {
+    var valid = preValidation(props);
+    var insightType = 'category_outlier';
+    if (isString(valid))
+        return getNonSignificantInsight({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var _a = getAlgorithmCommonInput(props), dimension = _a.dimension, values = _a.values, measure = _a.measure;
+    if (isNil(dimension) || isNil(measure))
+        return getNonSignificantInsight({
+            detailInfo: 'Measure or dimension is empty.',
+            insightType: insightType,
+            infoType: 'verificationFailure',
+        });
+    if (distinct(values) === 1)
+        return getNonSignificantInsight({
+            insightType: insightType,
+            infoType: 'noInsight',
+            customInfo: { info: 'Each value in the data is the same. No outliers were found.' },
+        });
+    var data = props.data;
+    var outlierParameter = get(props, 'options.algorithmParameter.outlier');
+    var outliers = findOutliers(values, outlierParameter).outliers;
+    if (outliers.length === 0) {
+        var info = "No outliers were found using method ".concat((outlierParameter === null || outlierParameter === void 0 ? void 0 : outlierParameter.method) !== 'p-value' ? 'Inter Quartile Range' : 'Normal Distribution test', ".");
+        return getNonSignificantInsight({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+    }
+    var categoryOutliers = outliers.map(function (item) {
+        var index = item.index, significance = item.significance;
+        return {
+            type: insightType,
+            dimension: dimension,
+            measure: measure,
+            significance: significance,
+            index: index,
+            x: data[index][dimension],
+            y: data[index][measure],
+            significantInsight: true,
+        };
+    });
+    return categoryOutliers;
+};