@formant/ava 3.4.1-formant

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

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCorrelationInfo = exports.findCorrelation = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var data_1 = require("../../../data");
+var util_1 = require("../util");
+var constants_1 = require("../../../data/statistics/constants");
+function findCorrelation(x, y, pCorrTestParameter) {
+    var testResult = (0, data_1.pcorrtest)(x, y, pCorrTestParameter);
+    // @ts-ignore Type Result is missing the "pcorr"
+    var rejected = testResult.rejected, pcorr = testResult.pcorr;
+    if (rejected) {
+        return {
+            pcorr: pcorr,
+            significance: Math.abs(pcorr),
+        };
+    }
+    return null;
+}
+exports.findCorrelation = findCorrelation;
+var getCorrelationInfo = function (props) {
+    var _a, _b;
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'correlation';
+    var data = props.data, measures = props.measures, dimensions = props.dimensions, options = props.options;
+    if ((0, lodash_1.isString)(valid) || !dimensions)
+        return (0, util_1.getNonSignificantInsight)(tslib_1.__assign({ insightType: insightType, infoType: 'verificationFailure' }, ((0, lodash_1.isString)(valid) ? { detailInfo: valid } : {})));
+    var xField = measures[0].fieldName;
+    var yField = measures[1].fieldName;
+    var x = data.map(function (item) { return item === null || item === void 0 ? void 0 : item[xField]; });
+    var y = data.map(function (item) { return item === null || item === void 0 ? void 0 : item[yField]; });
+    var correlationParameter = (_a = options === null || options === void 0 ? void 0 : options.algorithmParameter) === null || _a === void 0 ? void 0 : _a.correlation;
+    var result = findCorrelation(x, y, correlationParameter);
+    if (result) {
+        return [
+            tslib_1.__assign(tslib_1.__assign({}, result), { type: insightType, measures: [xField, yField], significantInsight: true }),
+        ];
+    }
+    var info = "The Pearson product-moment correlation test does not pass at the specified significance level ".concat((_b = correlationParameter === null || correlationParameter === void 0 ? void 0 : correlationParameter.alpha) !== null && _b !== void 0 ? _b : constants_1.DEFAULT_PCORRTEST_OPTIONS.alpha, ".");
+    return (0, util_1.getNonSignificantInsight)({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+};
+exports.getCorrelationInfo = getCorrelationInfo;

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

@@ -0,0 +1,4 @@
+import type { Measure, InsightInfo, InsightType, PatternInfo, HomogeneousPatternInfo } from '../../types';
+export type PatternCollection = Partial<Record<InsightType, PatternInfo[]>>;
+export declare function extractHomogeneousPatternsForMeasures(measures: Measure[], insightsCollection: (InsightInfo<PatternInfo> | null)[]): HomogeneousPatternInfo[];
+export declare function extractHomogeneousPatternsForSiblingGroups(siblingItems: string[], insightsCollection: (InsightInfo<PatternInfo> | null)[]): HomogeneousPatternInfo[];

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractHomogeneousPatternsForSiblingGroups = exports.extractHomogeneousPatternsForMeasures = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var constant_1 = require("../../constant");
+/**
+ * homogeneous data pattern (HDP) represents a set of basic data patterns that share certain relations. HDP are identified by categorizing basic data patterns (within an HDP) into commonness(es) and exceptions considering inter-pattern similarity,
+ */
+function extractHomogeneousPatterns(collection, type) {
+    var _a, _b;
+    var homogeneousPatterns = [];
+    var scopeLength = collection.length;
+    var validScopes = collection.filter(function (item) { var _a; return item.patterns && ((_a = item.patterns) === null || _a === void 0 ? void 0 : _a.length) > 0; });
+    if (validScopes.length > 1) {
+        if (type === 'trend') {
+            var parts = Object.values((0, lodash_1.groupBy)(collection, 'patterns.0.trend')).sort(function (a, b) { return b.length - a.length; });
+            if (parts.length === 2 &&
+                ((_b = (_a = parts[0][0]) === null || _a === void 0 ? void 0 : _a.patterns) === null || _b === void 0 ? void 0 : _b.length) &&
+                parts[0].length / scopeLength > 0.75 &&
+                parts[1].length < 5) {
+                homogeneousPatterns.push({
+                    type: 'exception',
+                    insightType: type,
+                    childPatterns: (0, lodash_1.flatten)(validScopes.map(function (item) { return item.patterns; })),
+                    commonSet: parts[0].map(function (item) { return item.key; }),
+                    exceptions: parts[1].map(function (item) { return item.key; }),
+                    significance: 1 - parts[1].length / scopeLength,
+                });
+            }
+            else {
+                parts.forEach(function (part) {
+                    var _a;
+                    var ratio = part.length / scopeLength;
+                    if (ratio > 0.3 && part.length >= 3 && ((_a = part[0]) === null || _a === void 0 ? void 0 : _a.patterns)) {
+                        var childPatterns = (0, lodash_1.flatten)(part.map(function (item) { return item.patterns; }));
+                        if (childPatterns.length) {
+                            homogeneousPatterns.push({
+                                type: 'commonness',
+                                insightType: type,
+                                childPatterns: childPatterns,
+                                commonSet: part.map(function (item) { return item.key; }),
+                                significance: ratio,
+                            });
+                        }
+                    }
+                });
+            }
+        }
+        if (['change_point', 'outlier', 'time_series_outlier'].includes(type)) {
+            var commonSetIndexes = Object.values((0, lodash_1.groupBy)((0, lodash_1.flatten)(validScopes.map(function (item) { return item.patterns.map(function (item) { return item.index; }); })))).sort(function (a, b) { return b.length - a.length; });
+            commonSetIndexes.forEach(function (indexArr) {
+                var ratio = indexArr.length / scopeLength;
+                if (ratio > 0.3 && indexArr.length >= 3) {
+                    var scopes = validScopes.filter(function (item) {
+                        return item.patterns.some(function (item) { return item.index === indexArr[0]; });
+                    });
+                    var childPatterns = (0, lodash_1.flatten)(scopes.map(function (item) { return item.patterns.filter(function (item) { return item.index === indexArr[0]; }); }));
+                    homogeneousPatterns.push({
+                        type: 'commonness',
+                        insightType: type,
+                        childPatterns: childPatterns,
+                        commonSet: scopes.map(function (item) { return item.key; }),
+                        significance: ratio,
+                    });
+                }
+            });
+        }
+    }
+    return homogeneousPatterns;
+}
+function extractHomogeneousPatternsForMeasures(measures, insightsCollection) {
+    var series = measures.map(function (item) { return item.fieldName; });
+    var patternsForAllMeasures = insightsCollection.map(function (item) { return item === null || item === void 0 ? void 0 : item.patterns; });
+    var homogeneousPatterns = [];
+    constant_1.PATTERN_TYPES.forEach(function (type) {
+        var patternCollection = patternsForAllMeasures.map(function (item, index) { return ({
+            key: series[index],
+            patterns: item === null || item === void 0 ? void 0 : item.filter(function (item) { return item.type === type; }),
+        }); });
+        var patterns = extractHomogeneousPatterns(patternCollection, type);
+        homogeneousPatterns.push.apply(homogeneousPatterns, tslib_1.__spreadArray([], tslib_1.__read(patterns), false));
+    });
+    return homogeneousPatterns;
+}
+exports.extractHomogeneousPatternsForMeasures = extractHomogeneousPatternsForMeasures;
+function extractHomogeneousPatternsForSiblingGroups(siblingItems, insightsCollection) {
+    var groupLength = insightsCollection.length;
+    if (siblingItems.length !== groupLength)
+        return [];
+    var patternsForSiblingGroup = insightsCollection.map(function (item) { return item === null || item === void 0 ? void 0 : item.patterns; });
+    var homogeneousPatterns = [];
+    constant_1.PATTERN_TYPES.forEach(function (type) {
+        var patternCollection = patternsForSiblingGroup.map(function (arr, index) { return ({
+            key: siblingItems[index],
+            patterns: arr === null || arr === void 0 ? void 0 : arr.filter(function (item) { return item.type === type; }),
+        }); });
+        var patterns = extractHomogeneousPatterns(patternCollection, type);
+        homogeneousPatterns.push.apply(homogeneousPatterns, tslib_1.__spreadArray([], tslib_1.__read(patterns), false));
+    });
+    return homogeneousPatterns;
+}
+exports.extractHomogeneousPatternsForSiblingGroups = extractHomogeneousPatternsForSiblingGroups;

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

@@ -0,0 +1,8 @@
+import type { GetPatternInfo, LowVarianceInfo, LowVarianceParameter } from '../../types';
+type LowVarianceItem = {
+    significance: number;
+    mean: number;
+};
+export declare function findLowVariance(values: number[], lowVarianceParameter?: LowVarianceParameter): LowVarianceItem | null;
+export declare const getLowVarianceInfo: GetPatternInfo<LowVarianceInfo>;
+export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLowVarianceInfo = exports.findLowVariance = void 0;
+var lodash_1 = require("lodash");
+var data_1 = require("../../../data");
+var util_1 = require("../util");
+// Coefficient of variation threshold
+var CV_THRESHOLD = 0.15;
+function findLowVariance(values, lowVarianceParameter) {
+    var cv = (0, data_1.coefficientOfVariance)(values);
+    var cvThreshold = (lowVarianceParameter === null || lowVarianceParameter === void 0 ? void 0 : lowVarianceParameter.cvThreshold) || CV_THRESHOLD;
+    if (cv >= cvThreshold) {
+        return null;
+    }
+    // The smaller the CV is, the greater the significance is.
+    var significance = 1 - cv;
+    var meanValue = (0, data_1.mean)(values);
+    return {
+        significance: significance,
+        mean: meanValue,
+    };
+}
+exports.findLowVariance = findLowVariance;
+var getLowVarianceInfo = function (props) {
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'low_variance';
+    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',
+        });
+    var lowVarianceParameter = (0, lodash_1.get)(props, 'options.algorithmParameter.lowVariance');
+    var lowVariance = findLowVariance(values, lowVarianceParameter);
+    if (lowVariance) {
+        var significance = lowVariance.significance, mean_1 = lowVariance.mean;
+        return [
+            {
+                type: insightType,
+                dimension: dimension,
+                measure: measure,
+                significance: significance,
+                mean: mean_1,
+                significantInsight: true,
+            },
+        ];
+    }
+    var info = "The coefficient of variance of the data is greater than ".concat((lowVarianceParameter === null || lowVarianceParameter === void 0 ? void 0 : lowVarianceParameter.cvThreshold) || CV_THRESHOLD, ". The data does not follow a uniform distribution.");
+    return (0, util_1.getNonSignificantInsight)({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+};
+exports.getLowVarianceInfo = getLowVarianceInfo;

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

@@ -0,0 +1,10 @@
+import type { GetPatternInfo, MajorityInfo, MajorityParameter } from '../../types';
+type MajorityItem = {
+    index: number;
+    significance: number;
+    value: number;
+    proportion: number;
+};
+export declare function findMajority(values: number[], majorityParameter?: MajorityParameter): MajorityItem | null;
+export declare const getMajorityInfo: GetPatternInfo<MajorityInfo>;
+export {};

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMajorityInfo = exports.findMajority = void 0;
+var lodash_1 = require("lodash");
+var util_1 = require("../util");
+var DEFAULT_PROPORTION_LIMIT = 0.6;
+function findMajority(values, majorityParameter) {
+    var sum = 0;
+    var max = -Infinity;
+    var maxIndex = -1;
+    for (var i = 0; i < (values === null || values === void 0 ? void 0 : values.length); i += 1) {
+        sum += values[i];
+        if (values[i] > max) {
+            max = values[i];
+            maxIndex = i;
+        }
+    }
+    var proportionLimit = (majorityParameter === null || majorityParameter === void 0 ? void 0 : majorityParameter.limit) || DEFAULT_PROPORTION_LIMIT;
+    if (sum === 0)
+        return null;
+    var proportion = max / sum;
+    if (proportion > proportionLimit && proportion < 1) {
+        return {
+            index: maxIndex,
+            value: max,
+            proportion: proportion,
+            significance: proportion,
+        };
+    }
+    return null;
+}
+exports.findMajority = findMajority;
+var getMajorityInfo = function (props) {
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'majority';
+    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 majorityParameter = (0, lodash_1.get)(props, 'options.algorithmParameter.majority');
+    var majority = findMajority(values, majorityParameter);
+    if (majority) {
+        var significance = majority.significance, index = majority.index, proportion = majority.proportion;
+        return [
+            {
+                type: insightType,
+                dimension: dimension,
+                measure: measure,
+                significance: significance,
+                index: index,
+                proportion: proportion,
+                x: data[index][dimension],
+                y: data[index][measure],
+                significantInsight: true,
+            },
+        ];
+    }
+    var info = "After disassembling with the given dimension, the proportion of the maximum value does not exceed ".concat((majorityParameter === null || majorityParameter === void 0 ? void 0 : majorityParameter.limit) || DEFAULT_PROPORTION_LIMIT, ".");
+    return (0, util_1.getNonSignificantInsight)({
+        insightType: insightType,
+        infoType: 'noInsight',
+        customInfo: { info: info, dimension: dimension, measure: measure },
+    });
+};
+exports.getMajorityInfo = getMajorityInfo;

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

@@ -0,0 +1,2 @@
+import type { GetPatternInfo, TimeSeriesOutlierInfo } from '../../types';
+export declare const getTimeSeriesOutlierInfo: GetPatternInfo<TimeSeriesOutlierInfo>;

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

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTimeSeriesOutlierInfo = void 0;
+var lodash_1 = require("lodash");
+var data_1 = require("../../../data");
+var constant_1 = require("../../constant");
+var util_1 = require("../util");
+var categoryOutlier_1 = require("./categoryOutlier");
+// detect the outliers using LOWESS
+function findTimeSeriesOutliers(values, outlierParameter) {
+    var indexes = Array(values.length)
+        .fill(0)
+        .map(function (_, index) { return index; });
+    var baseline = (0, data_1.lowess)(indexes, values, { nSteps: constant_1.LOWESS_N_STEPS });
+    var residuals = values.map(function (item, index) { return item - baseline.y[index]; });
+    var _a = (0, categoryOutlier_1.findOutliers)(residuals, outlierParameter), outliers = _a.outliers, thresholds = _a.thresholds;
+    return { outliers: outliers, baselines: baseline.y, thresholds: thresholds };
+}
+var getTimeSeriesOutlierInfo = function (props) {
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'time_series_outlier';
+    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',
+        });
+    if ((0, data_1.distinct)(values) === 1)
+        return (0, util_1.getNonSignificantInsight)({ insightType: insightType, infoType: 'noInsight' });
+    var outlierParameter = (0, lodash_1.get)(props, 'options.algorithmParameter.outlier');
+    var _b = findTimeSeriesOutliers(values, outlierParameter), outliers = _b.outliers, baselines = _b.baselines, thresholds = _b.thresholds;
+    if (outliers.length === 0)
+        return (0, util_1.getNonSignificantInsight)({
+            insightType: insightType,
+            infoType: 'noInsight',
+            customInfo: {
+                baselines: baselines,
+                thresholds: thresholds,
+                dimension: dimension,
+                measure: measure,
+                info: 'No outliers were found.',
+            },
+        });
+    var timeSeriesOutliers = 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],
+            baselines: baselines,
+            thresholds: thresholds,
+            significantInsight: true,
+        };
+    });
+    return timeSeriesOutliers;
+};
+exports.getTimeSeriesOutlierInfo = getTimeSeriesOutlierInfo;

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

@@ -0,0 +1,9 @@
+import { CommonParameter, GetPatternInfo, TrendInfo } from '../../types';
+type TrendResult = {
+    significance: number;
+    trend: TrendInfo['trend'];
+    regression: TrendInfo['regression'];
+};
+export declare function findTimeSeriesTrend(series: number[], trendParameter: CommonParameter): TrendResult;
+export declare const getTrendInfo: GetPatternInfo<TrendInfo>;
+export {};

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTrendInfo = exports.findTimeSeriesTrend = void 0;
+var tslib_1 = require("tslib");
+var regression_1 = tslib_1.__importDefault(require("regression"));
+var lodash_1 = require("lodash");
+var algorithms_1 = require("../../algorithms");
+var util_1 = require("../util");
+var constant_1 = require("../../constant");
+function findTimeSeriesTrend(series, trendParameter) {
+    var _a;
+    var significance = (_a = trendParameter === null || trendParameter === void 0 ? void 0 : trendParameter.threshold) !== null && _a !== void 0 ? _a : constant_1.SIGNIFICANCE_LEVEL;
+    var testResult = algorithms_1.trendDirection.mkTest(series, significance);
+    var pValue = testResult.pValue, trend = testResult.trend;
+    var regressionResult = regression_1.default.linear(series.map(function (item, index) { return [index, item]; }));
+    var r2 = regressionResult.r2, points = regressionResult.points, equation = regressionResult.equation;
+    return {
+        trend: trend,
+        significance: 1 - pValue,
+        regression: {
+            r2: r2,
+            points: points.map(function (item) { return item[1]; }),
+            equation: equation,
+        },
+    };
+}
+exports.findTimeSeriesTrend = findTimeSeriesTrend;
+var getTrendInfo = function (props) {
+    var _a;
+    var valid = (0, util_1.preValidation)(props);
+    var insightType = 'trend';
+    if ((0, lodash_1.isString)(valid))
+        return (0, util_1.getNonSignificantInsight)({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var _b = (0, util_1.getAlgorithmCommonInput)(props), dimension = _b.dimension, values = _b.values, measure = _b.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 trendParameter = (0, lodash_1.get)(props, 'options.algorithmParameter.trend');
+    var result = findTimeSeriesTrend(values, trendParameter);
+    return [
+        tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, result), { type: 'trend', dimension: dimension, measure: measure }), (result.trend === 'no trend'
+            ? {
+                significantInsight: false,
+                info: "The Mann-Kendall (MK) test does not pass at the specified significance level ".concat((_a = trendParameter === null || trendParameter === void 0 ? void 0 : trendParameter.threshold) !== null && _a !== void 0 ? _a : constant_1.SIGNIFICANCE_LEVEL, "."),
+            }
+            : {
+                significantInsight: true,
+            })),
+    ];
+};
+exports.getTrendInfo = getTrendInfo;

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

@@ -0,0 +1,12 @@
+import { InsightExtractorProps, PatternInfo } from '../types';
+export declare const extractorMap: {
+    category_outlier: import("../types").GetPatternInfo<import("../types").CategoryOutlierInfo>;
+    trend: import("../types").GetPatternInfo<import("../types").TrendInfo>;
+    change_point: import("../types").GetPatternInfo<import("../types").ChangePointInfo>;
+    time_series_outlier: import("../types").GetPatternInfo<import("../types").TimeSeriesOutlierInfo>;
+    majority: import("../types").GetPatternInfo<import("../types").MajorityInfo>;
+    low_variance: import("../types").GetPatternInfo<import("../types").LowVarianceInfo>;
+    correlation: import("../types").GetPatternInfo<import("../types").CorrelationInfo>;
+};
+export declare const insightPatternsExtractor: (props: InsightExtractorProps) => PatternInfo[];
+export * from './checkers';

package/lib/insight/insights/index.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.insightPatternsExtractor = exports.extractorMap = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var categoryOutlier_1 = require("./extractors/categoryOutlier");
+var changePoint_1 = require("./extractors/changePoint");
+var correlation_1 = require("./extractors/correlation");
+var lowVariance_1 = require("./extractors/lowVariance");
+var majority_1 = require("./extractors/majority");
+var timeSeriesOutlier_1 = require("./extractors/timeSeriesOutlier");
+var trend_1 = require("./extractors/trend");
+var util_1 = require("./util");
+exports.extractorMap = {
+    category_outlier: categoryOutlier_1.getCategoryOutlierInfo,
+    trend: trend_1.getTrendInfo,
+    change_point: changePoint_1.getChangePointInfo,
+    time_series_outlier: timeSeriesOutlier_1.getTimeSeriesOutlierInfo,
+    majority: majority_1.getMajorityInfo,
+    low_variance: lowVariance_1.getLowVarianceInfo,
+    correlation: correlation_1.getCorrelationInfo,
+};
+var insightPatternsExtractor = function (props) {
+    var _a = props.insightType, insightType = _a === void 0 ? 'trend' : _a, options = props.options;
+    var _b = (options || {}).filterInsight, filterInsight = _b === void 0 ? false : _b;
+    var extractor = exports.extractorMap[insightType];
+    if (!(0, lodash_1.isFunction)(extractor))
+        return [];
+    return (0, lodash_1.flow)(tslib_1.__spreadArray([extractor], tslib_1.__read((filterInsight ? [util_1.pickValidPattern] : [])), false))(props);
+};
+exports.insightPatternsExtractor = insightPatternsExtractor;
+tslib_1.__exportStar(require("./checkers"), exports);

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

@@ -0,0 +1,13 @@
+import { AlgorithmStandardInput, InsightExtractorProps, InsightType, NoPatternInfo, PatternInfo, PreValidationProps, TimeSeriesOutlierInfo } from '../types';
+export declare const calculatePValue: (values: number[], target: number, alternative?: 'two-sided' | 'less' | 'greater') => number;
+export declare const calculateOutlierThresholds: (values: number[], significance: number, alternative?: 'two-sided' | 'less' | 'greater') => [number, number];
+export declare const getAlgorithmCommonInput: ({ data, dimensions, measures, }: InsightExtractorProps) => AlgorithmStandardInput;
+export declare const preValidation: ({ data, dimensions, measures, options, insightType, }: PreValidationProps) => string | true;
+export declare const getNonSignificantInsight: ({ infoType, insightType, detailInfo, customInfo, }: {
+    insightType: InsightType;
+    detailInfo?: string;
+    infoType: 'verificationFailure' | 'noInsight';
+    customInfo?: Record<string, any>;
+}) => [NoPatternInfo];
+export declare const pickValidPattern: (infos?: PatternInfo[]) => PatternInfo[];
+export declare const pickValidTimeSeriesOutlierPatterns: (infos?: TimeSeriesOutlierInfo[]) => TimeSeriesOutlierInfo[];

package/lib/insight/insights/util.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickValidTimeSeriesOutlierPatterns = exports.pickValidPattern = exports.getNonSignificantInsight = exports.preValidation = exports.getAlgorithmCommonInput = exports.calculateOutlierThresholds = exports.calculatePValue = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var data_1 = require("../../data");
+var preprocess_1 = require("../pipeline/preprocess");
+var constant_1 = require("../constant");
+var checkers_1 = require("./checkers");
+var calculatePValue = function (values, target, alternative) {
+    if (alternative === void 0) { alternative = 'two-sided'; }
+    var meanValue = (0, lodash_1.mean)(values);
+    var std = (0, data_1.standardDeviation)(values);
+    var cdfValue = (0, data_1.cdf)(target, meanValue, std);
+    if (alternative === 'two-sided')
+        return cdfValue < 0.5 ? 2 * cdfValue : 2 * (1 - cdfValue);
+    if (alternative === 'less')
+        return cdfValue;
+    return 1 - cdfValue;
+};
+exports.calculatePValue = calculatePValue;
+var calculateOutlierThresholds = function (values, significance, alternative) {
+    if (alternative === void 0) { alternative = 'two-sided'; }
+    var meanValue = (0, lodash_1.mean)(values);
+    var std = (0, data_1.standardDeviation)(values);
+    var p = 1 - significance;
+    if (alternative === 'greater')
+        return [(0, data_1.normalDistributionQuantile)(significance, meanValue, std), (0, data_1.max)(values)];
+    if (alternative === 'less')
+        return [(0, data_1.min)(values), (0, data_1.normalDistributionQuantile)(p, meanValue, std)];
+    return [
+        (0, data_1.normalDistributionQuantile)(p / 2, meanValue, std),
+        (0, data_1.normalDistributionQuantile)(significance + p / 2, meanValue, std),
+    ];
+};
+exports.calculateOutlierThresholds = calculateOutlierThresholds;
+var getAlgorithmCommonInput = function (_a) {
+    var _b, _c;
+    var data = _a.data, dimensions = _a.dimensions, measures = _a.measures;
+    var dimension = (_b = dimensions === null || dimensions === void 0 ? void 0 : dimensions[0]) === null || _b === void 0 ? void 0 : _b.fieldName;
+    var measure = (_c = measures === null || measures === void 0 ? void 0 : measures[0]) === null || _c === void 0 ? void 0 : _c.fieldName;
+    var values = data.map(function (item) { return Number(item === null || item === void 0 ? void 0 : item[measure]); });
+    return { dimension: dimension, measure: measure, values: values };
+};
+exports.getAlgorithmCommonInput = getAlgorithmCommonInput;
+var preValidation = function (_a) {
+    var data = _a.data, dimensions = _a.dimensions, measures = _a.measures, options = _a.options, insightType = _a.insightType;
+    var _b = options || {}, _c = _b.dataValidation, dataValidation = _c === void 0 ? false : _c, dataProcessInfo = _b.dataProcessInfo;
+    if (!data || data.length === 0)
+        return 'No data. ';
+    if (!dataValidation)
+        return true;
+    var filteredData = data.filter(function (item) { return !Object.values(item).some(function (v) { return v === null || v === undefined; }); });
+    var dataProps = (0, preprocess_1.dataToDataProps)(filteredData, dataProcessInfo);
+    var fieldPropsMap = dataProps.reduce(function (acc, item) {
+        acc[item.name] = item;
+        return acc;
+    }, {});
+    var checker = checkers_1.ExtractorCheckers[insightType];
+    if (!checker)
+        return true;
+    var result = checker({
+        data: data,
+        subjectInfo: { dimensions: dimensions === null || dimensions === void 0 ? void 0 : dimensions.map(function (dim) { return dim.fieldName; }), measures: measures, subspace: [] },
+        fieldPropsMap: fieldPropsMap,
+    });
+    return result;
+};
+exports.preValidation = preValidation;
+var getNonSignificantInsight = function (_a) {
+    var infoType = _a.infoType, insightType = _a.insightType, _b = _a.detailInfo, detailInfo = _b === void 0 ? '' : _b, _c = _a.customInfo, customInfo = _c === void 0 ? {} : _c;
+    var info = "".concat(detailInfo).concat(infoType === 'noInsight' ? constant_1.NO_PATTERN_INFO : constant_1.VERIFICATION_FAILURE_INFO);
+    return [
+        tslib_1.__assign({ significantInsight: false, type: insightType, info: info, significance: 0 }, customInfo),
+    ];
+};
+exports.getNonSignificantInsight = getNonSignificantInsight;
+var pickValidPattern = function (infos) {
+    if (infos === void 0) { infos = []; }
+    return infos.filter(function (info) { return info.significantInsight; });
+};
+exports.pickValidPattern = pickValidPattern;
+var pickValidTimeSeriesOutlierPatterns = function (infos) {
+    if (infos === void 0) { infos = []; }
+    return infos.filter(function (info) { return ![info.baselines, info.thresholds, info.x].every(lodash_1.isNil); });
+};
+exports.pickValidTimeSeriesOutlierPatterns = pickValidTimeSeriesOutlierPatterns;

package/lib/insight/narrative/factory.d.ts

@@ -0,0 +1,6 @@
+import type { InsightType, HomogeneousInsightType } from '../types';
+import type { InsightNarrativeStrategy } from './strategy/base';
+export default class InsightNarrativeStrategyFactory {
+    private static narrativeStrategyMap;
+    static getStrategy(type: InsightType | HomogeneousInsightType): InsightNarrativeStrategy<any>;
+}

package/lib/insight/narrative/factory.js

@@ -0,0 +1,25 @@
+"use strict";
+var _this = this;
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var insightNarrativeStrategies = tslib_1.__importStar(require("./strategy"));
+var InsightNarrativeStrategyFactory = /** @class */ (function () {
+    function InsightNarrativeStrategyFactory() {
+    }
+    InsightNarrativeStrategyFactory.getStrategy = function (type) {
+        var strategy = InsightNarrativeStrategyFactory.narrativeStrategyMap.get(type);
+        if (!strategy)
+            throw Error("There is no description policy for this '".concat(type, "'."));
+        return strategy;
+    };
+    var _a;
+    _a = InsightNarrativeStrategyFactory;
+    InsightNarrativeStrategyFactory.narrativeStrategyMap = new Map();
+    (function () {
+        Object.values(insightNarrativeStrategies).forEach(function (Strategy) {
+            _a.narrativeStrategyMap.set(Strategy.insightType, new Strategy());
+        });
+    })();
+    return InsightNarrativeStrategyFactory;
+}());
+exports.default = InsightNarrativeStrategyFactory;

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

@@ -0,0 +1,3 @@
+import type { HomogeneousInsightInfo } from './strategy/base';
+import type { InsightInfo, InsightVisualizationOptions, PatternInfo } from '../types';
+export default function generateInsightNarrative(insightInfo: Omit<InsightInfo<PatternInfo>, 'visualizationSpecs'> | HomogeneousInsightInfo, options: InsightVisualizationOptions): import("../..").ParagraphSpec[];

package/lib/insight/narrative/index.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+var factory_1 = tslib_1.__importDefault(require("./factory"));
+function isHomogeneousPattern(insightInfo) {
+    return 'childPatterns' in insightInfo;
+}
+function generateInsightNarrative(insightInfo, options) {
+    var _a;
+    var insightType = isHomogeneousPattern(insightInfo) ? insightInfo === null || insightInfo === void 0 ? void 0 : insightInfo.type : (_a = insightInfo === null || insightInfo === void 0 ? void 0 : insightInfo.patterns[0]) === null || _a === void 0 ? void 0 : _a.type;
+    if (!insightType)
+        throw Error('insight info has no insight type');
+    var lang = options.lang;
+    var strategy = factory_1.default.getStrategy(insightType);
+    var result = strategy.generateTextSpec(insightInfo, lang);
+    return result;
+}
+exports.default = generateInsightNarrative;