@formant/ava 3.4.1-formant

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.intervalMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var constants_1 = require("../../constants");
+/** get mark for point patterns, the patterns should have same dimension and measure */
+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 = tslib_1.__assign(tslib_1.__assign({ type: 'interval', data: data, encode: {
+            x: 'x',
+            y: 'y',
+        } }, config), { style: tslib_1.__assign(tslib_1.__assign({}, config === null || config === void 0 ? void 0 : config.style), { fill: constants_1.INSIGHT_COLOR_PLATTE.outlier }) });
+    return intervalMark;
+};
+exports.intervalMarkStrategy = intervalMarkStrategy;

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

@@ -0,0 +1,3 @@
+import { LineMark } from '@antv/g2';
+import { LineMarkConfig, LineMarkData } from '../../types';
+export declare const lineMarkStrategy: ({ points, x, y }: LineMarkData, { encode, style, label, tooltip }: LineMarkConfig) => LineMark;

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

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lineMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var constants_1 = require("../../constants");
+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: tslib_1.__assign({ lineDash: [2, 2], stroke: constants_1.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 tslib_1.__assign(tslib_1.__assign({}, common), { type: 'line', data: points, encode: tslib_1.__assign({ x: 'x', y: 'y' }, encode) });
+    }
+    if (x) {
+        return tslib_1.__assign(tslib_1.__assign({}, common), { type: 'lineX', data: [x] });
+    }
+    if (y) {
+        return tslib_1.__assign(tslib_1.__assign({}, common), { type: 'lineY', data: [y] });
+    }
+    return null;
+};
+exports.lineMarkStrategy = lineMarkStrategy;

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

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

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

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+/** get mark for point patterns, the patterns should have same dimension and measure */
+var pointMarkStrategy = function (patterns, config) {
+    var data = [];
+    patterns.forEach(function (_a) {
+        var x = _a.x, y = _a.y;
+        if ((0, lodash_1.isNil)(x) || (0, lodash_1.isNil)(y))
+            return;
+        data.push({ x: x, y: y });
+    });
+    var pointMark = tslib_1.__assign({ type: 'point', data: data, encode: {
+            x: 'x',
+            y: 'y',
+        } }, config);
+    return pointMark;
+};
+exports.pointMarkStrategy = pointMarkStrategy;

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

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

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.textMarkStrategy = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var constants_1 = require("../../constants");
+/** get mark for point patterns, the patterns should have same dimension and measure */
+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 = (0, lodash_1.isFunction)(label) ? label(pattern) : label;
+        var value = (0, lodash_1.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: tslib_1.__assign(tslib_1.__assign({}, constants_1.TEXT_STYLE), style),
+    };
+};
+exports.textMarkStrategy = textMarkStrategy;

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

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

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

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewSpecStrategy = exports.insight2ChartStrategy = void 0;
+var tslib_1 = require("tslib");
+var chart_1 = require("./chart");
+Object.defineProperty(exports, "insight2ChartStrategy", { enumerable: true, get: function () { return chart_1.insight2ChartStrategy; } });
+var viewSpec_1 = require("./viewSpec");
+Object.defineProperty(exports, "viewSpecStrategy", { enumerable: true, get: function () { return viewSpec_1.viewSpecStrategy; } });
+tslib_1.__exportStar(require("./commonMarks"), exports);
+tslib_1.__exportStar(require("./augmentedMarks"), exports);

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

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

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

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

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

@@ -0,0 +1,60 @@
+import type { AreaMark, IntervalMark, LineMark, Mark, PointMark, TextMark } from '@antv/g2';
+import type { Datum } from '../types';
+type LabelType = string | ((d: Datum) => string);
+export type TextMarkConfig = {
+    label?: LabelType;
+    style?: Mark['style'];
+    formatter?: (value: number) => string;
+};
+export type PointMarkConfig = {
+    style?: Mark['style'];
+    tooltip?: Mark['tooltip'];
+};
+export type LineMarkData = {
+    /** draw a vertical line at x value */
+    x?: number;
+    /** draw a horizontal line at y value */
+    y?: number;
+    /** draw a line using specific points */
+    points?: {
+        x: number;
+        y: number;
+    }[];
+};
+export type LineMarkConfig = {
+    encode?: Mark['encode'];
+    label?: string;
+    style?: Mark['style'];
+    tooltip?: Mark['tooltip'];
+};
+export type AreaMarkData = {
+    x: number;
+    y: [number, number];
+}[];
+export type AreaMarkConfig = {
+    encode?: Mark['encode'];
+    style?: Mark['style'];
+    tooltip?: Mark['tooltip'];
+};
+export type IntervalMarkConfig = {
+    style?: Mark['style'];
+};
+export type ChangePointMark = {
+    changePoint: (PointMark | TextMark)[];
+};
+export type TrendMark = {
+    trendLine: LineMark[];
+};
+export type TimeSeriesOutlierMark = {
+    trendLine: LineMark[];
+    anomalyArea: AreaMark[];
+    outliers?: PointMark[];
+};
+export type CategoryOutlierMark = {
+    categoryOutlier: (IntervalMark | TextMark)[];
+};
+export type LowVarianceMark = {
+    meanLine: LineMark[];
+};
+export type AugmentedMarks = ChangePointMark[] | TrendMark[] | TimeSeriesOutlierMark[] | CategoryOutlierMark[] | LowVarianceMark[];
+export {};

package/lib/insight/chart/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,3 @@
+import { Mark } from '@antv/g2';
+import { AugmentedMarks } from './types';
+export declare const augmentedMarks2Marks: (augmentedMarks: AugmentedMarks) => Mark[];

package/lib/insight/chart/utils.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.augmentedMarks2Marks = void 0;
+var lodash_1 = require("lodash");
+var augmentedMarks2Marks = function (augmentedMarks) {
+    return (0, lodash_1.flattenDeep)((0, lodash_1.map)(augmentedMarks, function (augmentedMark) { return Object.values(augmentedMark); }));
+};
+exports.augmentedMarks2Marks = augmentedMarks2Marks;

package/lib/insight/constant.d.ts

@@ -0,0 +1,12 @@
+export declare const SIGNIFICANCE_BENCHMARK = 0.95;
+export declare const SIGNIFICANCE_LEVEL = 0.05;
+export declare const INSIGHT_SCORE_BENCHMARK = 0.01;
+export declare const IMPACT_SCORE_WEIGHT = 0.2;
+export declare const INSIGHT_DEFAULT_LIMIT = 20;
+export declare const IQR_K = 1.5;
+export declare const LOWESS_N_STEPS = 2;
+export declare const PATTERN_TYPES: readonly ["category_outlier", "trend", "change_point", "time_series_outlier", "majority", "low_variance", "correlation"];
+export declare const HOMOGENEOUS_PATTERN_TYPES: readonly ["commonness", "exception"];
+export declare const VERIFICATION_FAILURE_INFO = "The input does not meet the requirements.";
+export declare const NO_PATTERN_INFO = "No insights were found at the specified significance threshold.";
+export declare const CHANGE_POINT_SIGNIFICANCE_BENCHMARK = 0.15;

package/lib/insight/constant.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CHANGE_POINT_SIGNIFICANCE_BENCHMARK = exports.NO_PATTERN_INFO = exports.VERIFICATION_FAILURE_INFO = exports.HOMOGENEOUS_PATTERN_TYPES = exports.PATTERN_TYPES = exports.LOWESS_N_STEPS = exports.IQR_K = exports.INSIGHT_DEFAULT_LIMIT = exports.IMPACT_SCORE_WEIGHT = exports.INSIGHT_SCORE_BENCHMARK = exports.SIGNIFICANCE_LEVEL = exports.SIGNIFICANCE_BENCHMARK = void 0;
+// Should be confidence level. Is the SIGNIFICANCE_BENCHMARK naming correct? by @pddpd
+exports.SIGNIFICANCE_BENCHMARK = 0.95;
+exports.SIGNIFICANCE_LEVEL = 0.05;
+exports.INSIGHT_SCORE_BENCHMARK = 0.01;
+exports.IMPACT_SCORE_WEIGHT = 0.2;
+exports.INSIGHT_DEFAULT_LIMIT = 20;
+exports.IQR_K = 1.5;
+exports.LOWESS_N_STEPS = 2;
+exports.PATTERN_TYPES = [
+    'category_outlier',
+    'trend',
+    'change_point',
+    'time_series_outlier',
+    'majority',
+    'low_variance',
+    'correlation',
+];
+exports.HOMOGENEOUS_PATTERN_TYPES = ['commonness', 'exception'];
+exports.VERIFICATION_FAILURE_INFO = 'The input does not meet the requirements.';
+exports.NO_PATTERN_INFO = 'No insights were found at the specified significance threshold.';
+exports.CHANGE_POINT_SIGNIFICANCE_BENCHMARK = 0.15;

package/lib/insight/index.d.ts

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

package/lib/insight/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecificInsight = exports.generateInsightVisualizationSpec = exports.insightPatternsExtractor = exports.getInsights = void 0;
+var tslib_1 = require("tslib");
+var pipeline_1 = require("./pipeline");
+Object.defineProperty(exports, "getInsights", { enumerable: true, get: function () { return pipeline_1.getInsights; } });
+var insights_1 = require("./insights");
+Object.defineProperty(exports, "insightPatternsExtractor", { enumerable: true, get: function () { return insights_1.insightPatternsExtractor; } });
+var visualize_1 = require("./pipeline/visualize");
+Object.defineProperty(exports, "generateInsightVisualizationSpec", { enumerable: true, get: function () { return visualize_1.generateInsightVisualizationSpec; } });
+tslib_1.__exportStar(require("./types"), exports);
+var specificInsight_1 = require("./pipeline/specificInsight");
+Object.defineProperty(exports, "getSpecificInsight", { enumerable: true, get: function () { return specificInsight_1.getSpecificInsight; } });

package/lib/insight/insights/checkers.d.ts

@@ -0,0 +1,16 @@
+import { Datum, SubjectInfo, InsightType, DataProperty } from '../types';
+import type { LevelOfMeasurement } from '../../ckb';
+export type ExtractorChecker = (props: {
+    data: Datum[];
+    subjectInfo: SubjectInfo;
+    fieldPropsMap: Record<string, DataProperty>;
+    lom?: LevelOfMeasurement | LevelOfMeasurement[];
+}) => true | string;
+export declare const trendChecker: ExtractorChecker;
+export declare const categoryOutlierChecker: ExtractorChecker;
+export declare const changePointChecker: ExtractorChecker;
+export declare const timeSeriesChecker: ExtractorChecker;
+export declare const majorityChecker: ExtractorChecker;
+export declare const lowVarianceChecker: ExtractorChecker;
+export declare const correlationChecker: ExtractorChecker;
+export declare const ExtractorCheckers: Partial<Record<InsightType, ExtractorChecker>>;

package/lib/insight/insights/checkers.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtractorCheckers = exports.correlationChecker = exports.lowVarianceChecker = exports.majorityChecker = exports.timeSeriesChecker = exports.changePointChecker = exports.categoryOutlierChecker = exports.trendChecker = void 0;
+var lodash_1 = require("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 = (0, lodash_1.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;
+};
+var trendChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+exports.trendChecker = trendChecker;
+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'] });
+};
+exports.categoryOutlierChecker = categoryOutlierChecker;
+var changePointChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+exports.changePointChecker = changePointChecker;
+var timeSeriesChecker = function (_a) {
+    var data = _a.data, subjectInfo = _a.subjectInfo, fieldPropsMap = _a.fieldPropsMap;
+    return generalCheckerFor1M1D({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap, lom: 'Time' });
+};
+exports.timeSeriesChecker = timeSeriesChecker;
+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;
+};
+exports.majorityChecker = majorityChecker;
+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. ';
+};
+exports.lowVarianceChecker = lowVarianceChecker;
+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;
+};
+exports.correlationChecker = correlationChecker;
+exports.ExtractorCheckers = {
+    category_outlier: exports.categoryOutlierChecker,
+    trend: exports.trendChecker,
+    change_point: exports.changePointChecker,
+    time_series_outlier: exports.timeSeriesChecker,
+    low_variance: exports.lowVarianceChecker,
+    correlation: exports.correlationChecker,
+};

package/lib/insight/insights/extractors/categoryOutlier.d.ts

@@ -0,0 +1,12 @@
+import { CategoryOutlierInfo, GetPatternInfo, OutlierParameter } from '../../types';
+type OutlierItem = {
+    index: number;
+    significance: number;
+    value: number;
+};
+export declare const findOutliers: (values: number[], outlierParameter?: OutlierParameter) => {
+    outliers: OutlierItem[];
+    thresholds: [number, number];
+};
+export declare const getCategoryOutlierInfo: GetPatternInfo<CategoryOutlierInfo>;
+export {};

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCategoryOutlierInfo = exports.findOutliers = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var data_1 = require("../../../data");
+var algorithms_1 = require("../../algorithms");
+var constant_1 = require("../../constant");
+var util_1 = require("../util");
+var findOutliers = function (values, outlierParameter) {
+    var _a = outlierParameter || {}, method = _a.method, iqrK = _a.iqrK, _b = _a.confidenceInterval, confidenceInterval = _b === void 0 ? constant_1.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 = algorithms_1.categoryOutlier.IQR(values, { k: iqrK !== null && iqrK !== void 0 ? iqrK : constant_1.IQR_K });
+        var lowerOutlierIndexes = IQRResult.lower.indexes;
+        var upperOutlierIndexes = IQRResult.upper.indexes;
+        tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(lowerOutlierIndexes), false), tslib_1.__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 = (0, lodash_1.orderBy)(candidates, function (item) { return Math.abs((0, data_1.mean)(values) - item.value); }, ['desc']);
+        thresholds.push.apply(thresholds, tslib_1.__spreadArray([], tslib_1.__read((0, util_1.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 = (0, util_1.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 };
+};
+exports.findOutliers = findOutliers;
+var getCategoryOutlierInfo = function (props) {
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'category_outlier';
+    if ((0, lodash_1.isString)(valid))
+        return (0, util_1.getNonSignificantInsight)({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var _a = (0, util_1.getAlgorithmCommonInput)(props), dimension = _a.dimension, values = _a.values, measure = _a.measure;
+    if ((0, lodash_1.isNil)(dimension) || (0, lodash_1.isNil)(measure))
+        return (0, util_1.getNonSignificantInsight)({
+            detailInfo: 'Measure or dimension is empty.',
+            insightType: insightType,
+            infoType: 'verificationFailure',
+        });
+    if ((0, data_1.distinct)(values) === 1)
+        return (0, util_1.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 = (0, lodash_1.get)(props, 'options.algorithmParameter.outlier');
+    var outliers = (0, exports.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 (0, util_1.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;
+};
+exports.getCategoryOutlierInfo = getCategoryOutlierInfo;

package/lib/insight/insights/extractors/changePoint.d.ts

@@ -0,0 +1,8 @@
+import type { ChangePointInfo, CommonParameter, GetPatternInfo } from '../../types';
+type ChangePointItem = {
+    index: number;
+    significance: number;
+};
+export declare const findChangePoints: (series: number[], changePointsParameter: CommonParameter) => ChangePointItem[];
+export declare const getChangePointInfo: GetPatternInfo<ChangePointInfo>;
+export {};

package/lib/insight/insights/extractors/changePoint.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getChangePointInfo = exports.findChangePoints = void 0;
+var lodash_1 = require("lodash");
+var algorithms_1 = require("../../algorithms");
+var util_1 = require("../util");
+var constant_1 = require("../../constant");
+var findChangePoints = function (series, changePointsParameter) {
+    var _a;
+    var results = algorithms_1.changePoint.Bayesian(series);
+    var changePointsResult = [];
+    // significanceBenchmark is equivalent to the confidence interval in hypothesis testing
+    var significanceBenchmark = 1 - ((_a = changePointsParameter === null || changePointsParameter === void 0 ? void 0 : changePointsParameter.threshold) !== null && _a !== void 0 ? _a : constant_1.CHANGE_POINT_SIGNIFICANCE_BENCHMARK);
+    results.forEach(function (item) {
+        // item.significance is similar to confidence interval
+        if ((item === null || item === void 0 ? void 0 : item.index) >= 0 && (item === null || item === void 0 ? void 0 : item.significance) >= significanceBenchmark) {
+            changePointsResult.push(item);
+        }
+    });
+    return changePointsResult;
+};
+exports.findChangePoints = findChangePoints;
+var getChangePointInfo = function (props) {
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'change_point';
+    if ((0, lodash_1.isString)(valid))
+        return (0, util_1.getNonSignificantInsight)({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var data = props.data;
+    var _a = (0, util_1.getAlgorithmCommonInput)(props), dimension = _a.dimension, values = _a.values, measure = _a.measure;
+    if ((0, lodash_1.isNil)(dimension) || (0, lodash_1.isNil)(measure))
+        return (0, util_1.getNonSignificantInsight)({
+            detailInfo: 'Measure or dimension is empty.',
+            insightType: insightType,
+            infoType: 'verificationFailure',
+        });
+    var changePointsParameter = (0, lodash_1.get)(props, 'options.algorithmParameter.changePoint');
+    var changePoints = (0, exports.findChangePoints)(values, changePointsParameter);
+    if (changePoints.length === 0) {
+        var info = 'Bayesian Online Changepoint Detection does not pass.';
+        return (0, util_1.getNonSignificantInsight)({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+    }
+    var outliers = [];
+    changePoints.forEach(function (item) {
+        var index = item.index, significance = item.significance;
+        if (!(0, lodash_1.isNil)(data[index])) {
+            outliers.push({
+                type: insightType,
+                dimension: dimension,
+                measure: measure,
+                significance: significance,
+                index: index,
+                x: data[index][dimension],
+                y: data[index][measure],
+                significantInsight: true,
+            });
+        }
+    });
+    return outliers;
+};
+exports.getChangePointInfo = getChangePointInfo;

package/lib/insight/insights/extractors/correlation.d.ts

@@ -0,0 +1,9 @@
+import { PCorrTestParameter } from '../../../data/statistics/types';
+import { CorrelationInfo, GetPatternInfo } from '../../types';
+type CorrelationResult = {
+    significance: number;
+    pcorr: number;
+};
+export declare function findCorrelation(x: number[], y: number[], pCorrTestParameter?: PCorrTestParameter): CorrelationResult | null;
+export declare const getCorrelationInfo: GetPatternInfo<CorrelationInfo>;
+export {};