@formant/ava 3.4.1-formant

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

@@ -0,0 +1,55 @@
+import { get, isNil, isString } from 'lodash';
+import { changePoint } from '../../algorithms';
+import { getAlgorithmCommonInput, getNonSignificantInsight, preValidation } from '../util';
+import { CHANGE_POINT_SIGNIFICANCE_BENCHMARK } from '../../constant';
+export var findChangePoints = function (series, changePointsParameter) {
+    var _a;
+    var results = 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 : 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;
+};
+export var getChangePointInfo = function (props) {
+    var valid = preValidation(props);
+    var insightType = 'change_point';
+    if (isString(valid))
+        return getNonSignificantInsight({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var data = props.data;
+    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',
+        });
+    var changePointsParameter = get(props, 'options.algorithmParameter.changePoint');
+    var changePoints = findChangePoints(values, changePointsParameter);
+    if (changePoints.length === 0) {
+        var info = 'Bayesian Online Changepoint Detection does not pass.';
+        return getNonSignificantInsight({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+    }
+    var outliers = [];
+    changePoints.forEach(function (item) {
+        var index = item.index, significance = item.significance;
+        if (!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;
+};

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

@@ -0,0 +1,38 @@
+import { __assign } from "tslib";
+import { isString } from 'lodash';
+import { pcorrtest } from '../../../data';
+import { getNonSignificantInsight, preValidation } from '../util';
+import { DEFAULT_PCORRTEST_OPTIONS } from '../../../data/statistics/constants';
+export function findCorrelation(x, y, pCorrTestParameter) {
+    var testResult = 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;
+}
+export var getCorrelationInfo = function (props) {
+    var _a, _b;
+    var valid = preValidation(props);
+    var insightType = 'correlation';
+    var data = props.data, measures = props.measures, dimensions = props.dimensions, options = props.options;
+    if (isString(valid) || !dimensions)
+        return getNonSignificantInsight(__assign({ insightType: insightType, infoType: 'verificationFailure' }, (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 [
+            __assign(__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 : DEFAULT_PCORRTEST_OPTIONS.alpha, ".");
+    return getNonSignificantInsight({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+};

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

@@ -0,0 +1,98 @@
+import { __read, __spreadArray } from "tslib";
+import { groupBy, flatten } from 'lodash';
+import { PATTERN_TYPES } from '../../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(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: 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 = 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(groupBy(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 = 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;
+}
+export 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 = [];
+    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, __spreadArray([], __read(patterns), false));
+    });
+    return homogeneousPatterns;
+}
+export 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 = [];
+    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, __spreadArray([], __read(patterns), false));
+    });
+    return homogeneousPatterns;
+}

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

@@ -0,0 +1,49 @@
+import { get, isNil, isString } from 'lodash';
+import { coefficientOfVariance, mean } from '../../../data';
+import { getAlgorithmCommonInput, getNonSignificantInsight, preValidation } from '../util';
+// Coefficient of variation threshold
+var CV_THRESHOLD = 0.15;
+export function findLowVariance(values, lowVarianceParameter) {
+    var cv = 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 = mean(values);
+    return {
+        significance: significance,
+        mean: meanValue,
+    };
+}
+export var getLowVarianceInfo = function (props) {
+    var valid = preValidation(props);
+    var insightType = 'low_variance';
+    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',
+        });
+    var lowVarianceParameter = 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 getNonSignificantInsight({ insightType: insightType, infoType: 'noInsight', customInfo: { info: info } });
+};

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

@@ -0,0 +1,66 @@
+import { get, isNil, isString } from 'lodash';
+import { getAlgorithmCommonInput, getNonSignificantInsight, preValidation } from '../util';
+var DEFAULT_PROPORTION_LIMIT = 0.6;
+export 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;
+}
+export var getMajorityInfo = function (props) {
+    var valid = preValidation(props);
+    var insightType = 'majority';
+    if (isString(valid))
+        return getNonSignificantInsight({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var data = props.data;
+    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',
+        });
+    var majorityParameter = 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 getNonSignificantInsight({
+        insightType: insightType,
+        infoType: 'noInsight',
+        customInfo: { info: info, dimension: dimension, measure: measure },
+    });
+};

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

@@ -0,0 +1,61 @@
+import { get, isNil, isString } from 'lodash';
+import { distinct, lowess } from '../../../data';
+import { LOWESS_N_STEPS } from '../../constant';
+import { getAlgorithmCommonInput, getNonSignificantInsight, preValidation } from '../util';
+import { findOutliers } from './categoryOutlier';
+// detect the outliers using LOWESS
+function findTimeSeriesOutliers(values, outlierParameter) {
+    var indexes = Array(values.length)
+        .fill(0)
+        .map(function (_, index) { return index; });
+    var baseline = lowess(indexes, values, { nSteps: LOWESS_N_STEPS });
+    var residuals = values.map(function (item, index) { return item - baseline.y[index]; });
+    var _a = findOutliers(residuals, outlierParameter), outliers = _a.outliers, thresholds = _a.thresholds;
+    return { outliers: outliers, baselines: baseline.y, thresholds: thresholds };
+}
+export var getTimeSeriesOutlierInfo = function (props) {
+    var valid = preValidation(props);
+    var insightType = 'time_series_outlier';
+    if (isString(valid))
+        return getNonSignificantInsight({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var data = props.data;
+    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' });
+    var outlierParameter = get(props, 'options.algorithmParameter.outlier');
+    var _b = findTimeSeriesOutliers(values, outlierParameter), outliers = _b.outliers, baselines = _b.baselines, thresholds = _b.thresholds;
+    if (outliers.length === 0)
+        return 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;
+};

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

@@ -0,0 +1,49 @@
+import { __assign } from "tslib";
+import regression from 'regression';
+import { get, isNil, isString } from 'lodash';
+import { trendDirection } from '../../algorithms';
+import { getAlgorithmCommonInput, getNonSignificantInsight, preValidation } from '../util';
+import { SIGNIFICANCE_LEVEL } from '../../constant';
+export function findTimeSeriesTrend(series, trendParameter) {
+    var _a;
+    var significance = (_a = trendParameter === null || trendParameter === void 0 ? void 0 : trendParameter.threshold) !== null && _a !== void 0 ? _a : SIGNIFICANCE_LEVEL;
+    var testResult = trendDirection.mkTest(series, significance);
+    var pValue = testResult.pValue, trend = testResult.trend;
+    var regressionResult = regression.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,
+        },
+    };
+}
+export var getTrendInfo = function (props) {
+    var _a;
+    var valid = preValidation(props);
+    var insightType = 'trend';
+    if (isString(valid))
+        return getNonSignificantInsight({ detailInfo: valid, insightType: insightType, infoType: 'verificationFailure' });
+    var _b = getAlgorithmCommonInput(props), dimension = _b.dimension, values = _b.values, measure = _b.measure;
+    if (isNil(dimension) || isNil(measure))
+        return getNonSignificantInsight({
+            detailInfo: 'Measure or dimension is empty.',
+            insightType: insightType,
+            infoType: 'verificationFailure',
+        });
+    var trendParameter = get(props, 'options.algorithmParameter.trend');
+    var result = findTimeSeriesTrend(values, trendParameter);
+    return [
+        __assign(__assign(__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 : SIGNIFICANCE_LEVEL, "."),
+            }
+            : {
+                significantInsight: true,
+            })),
+    ];
+};

package/esm/insight/insights/index.js

@@ -0,0 +1,28 @@
+import { __read, __spreadArray } from "tslib";
+import { flow, isFunction } from 'lodash';
+import { getCategoryOutlierInfo } from './extractors/categoryOutlier';
+import { getChangePointInfo } from './extractors/changePoint';
+import { getCorrelationInfo } from './extractors/correlation';
+import { getLowVarianceInfo } from './extractors/lowVariance';
+import { getMajorityInfo } from './extractors/majority';
+import { getTimeSeriesOutlierInfo } from './extractors/timeSeriesOutlier';
+import { getTrendInfo } from './extractors/trend';
+import { pickValidPattern } from './util';
+export var extractorMap = {
+    category_outlier: getCategoryOutlierInfo,
+    trend: getTrendInfo,
+    change_point: getChangePointInfo,
+    time_series_outlier: getTimeSeriesOutlierInfo,
+    majority: getMajorityInfo,
+    low_variance: getLowVarianceInfo,
+    correlation: getCorrelationInfo,
+};
+export 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 = extractorMap[insightType];
+    if (!isFunction(extractor))
+        return [];
+    return flow(__spreadArray([extractor], __read((filterInsight ? [pickValidPattern] : [])), false))(props);
+};
+export * from './checkers';

package/esm/insight/insights/util.js

@@ -0,0 +1,77 @@
+import { __assign } from "tslib";
+import { isNil, mean } from 'lodash';
+import { standardDeviation, cdf, normalDistributionQuantile, max, min } from '../../data';
+import { dataToDataProps } from '../pipeline/preprocess';
+import { NO_PATTERN_INFO, VERIFICATION_FAILURE_INFO } from '../constant';
+import { ExtractorCheckers } from './checkers';
+export var calculatePValue = function (values, target, alternative) {
+    if (alternative === void 0) { alternative = 'two-sided'; }
+    var meanValue = mean(values);
+    var std = standardDeviation(values);
+    var cdfValue = 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;
+};
+export var calculateOutlierThresholds = function (values, significance, alternative) {
+    if (alternative === void 0) { alternative = 'two-sided'; }
+    var meanValue = mean(values);
+    var std = standardDeviation(values);
+    var p = 1 - significance;
+    if (alternative === 'greater')
+        return [normalDistributionQuantile(significance, meanValue, std), max(values)];
+    if (alternative === 'less')
+        return [min(values), normalDistributionQuantile(p, meanValue, std)];
+    return [
+        normalDistributionQuantile(p / 2, meanValue, std),
+        normalDistributionQuantile(significance + p / 2, meanValue, std),
+    ];
+};
+export 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 };
+};
+export 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 = dataToDataProps(filteredData, dataProcessInfo);
+    var fieldPropsMap = dataProps.reduce(function (acc, item) {
+        acc[item.name] = item;
+        return acc;
+    }, {});
+    var checker = 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;
+};
+export 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' ? NO_PATTERN_INFO : VERIFICATION_FAILURE_INFO);
+    return [
+        __assign({ significantInsight: false, type: insightType, info: info, significance: 0 }, customInfo),
+    ];
+};
+export var pickValidPattern = function (infos) {
+    if (infos === void 0) { infos = []; }
+    return infos.filter(function (info) { return info.significantInsight; });
+};
+export var pickValidTimeSeriesOutlierPatterns = function (infos) {
+    if (infos === void 0) { infos = []; }
+    return infos.filter(function (info) { return ![info.baselines, info.thresholds, info.x].every(isNil); });
+};

package/esm/insight/narrative/factory.js

@@ -0,0 +1,22 @@
+var _this = this;
+import * as insightNarrativeStrategies from './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;
+}());
+export default InsightNarrativeStrategyFactory;

package/esm/insight/narrative/index.js

@@ -0,0 +1,14 @@
+import InsightNarrativeStrategyFactory from './factory';
+function isHomogeneousPattern(insightInfo) {
+    return 'childPatterns' in insightInfo;
+}
+export default 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 = InsightNarrativeStrategyFactory.getStrategy(insightType);
+    var result = strategy.generateTextSpec(insightInfo, lang);
+    return result;
+}

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

@@ -0,0 +1,6 @@
+var InsightNarrativeStrategy = /** @class */ (function () {
+    function InsightNarrativeStrategy() {
+    }
+    return InsightNarrativeStrategy;
+}());
+export { InsightNarrativeStrategy };

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

@@ -0,0 +1,74 @@
+import { __extends } from "tslib";
+/* eslint-disable no-template-curly-in-string */
+import { generateTextSpec } from '../../../ntv';
+import { InsightNarrativeStrategy } from './base';
+import { getDefaultSeparator } from './helpers';
+var variableMetaMap = {
+    measure: {
+        varType: 'metric_name',
+    },
+    total: {
+        varType: 'metric_value',
+    },
+    '.x': {
+        varType: 'dim_value',
+    },
+};
+var CategoryOutlierNarrativeStrategy = /** @class */ (function (_super) {
+    __extends(CategoryOutlierNarrativeStrategy, _super);
+    function CategoryOutlierNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CategoryOutlierNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns;
+        var _a = patterns[0], dimension = _a.dimension, measure = _a.measure;
+        var spec = generateTextSpec({
+            structures: CategoryOutlierNarrativeStrategy.structures[lang],
+            variable: {
+                dimension: dimension,
+                measure: measure,
+                total: patterns.length,
+                patterns: patterns,
+            },
+            structureTemps: CategoryOutlierNarrativeStrategy.structureTemps[lang],
+        });
+        return spec.sections[0].paragraphs;
+    };
+    CategoryOutlierNarrativeStrategy.insightType = 'category_outlier';
+    CategoryOutlierNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '${measure} 在 ${dimension} 上有 ${total} 个类别相比其他维值突出：&{outliers}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: '${measure} has ${total} categories in the ${dimension} that are prominent compared to other dimensions: &{outliers}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    CategoryOutlierNarrativeStrategy.structureTemps = {
+        'zh-CN': [
+            {
+                templateId: 'outliers',
+                template: '${.x}',
+                separator: getDefaultSeparator('zh-CN'),
+                variableMetaMap: variableMetaMap,
+                useVariable: 'patterns',
+            },
+        ],
+        'en-US': [
+            {
+                templateId: 'outliers',
+                template: '${.x}',
+                separator: getDefaultSeparator('en-US'),
+                variableMetaMap: variableMetaMap,
+                useVariable: 'patterns',
+            },
+        ],
+    };
+    return CategoryOutlierNarrativeStrategy;
+}(InsightNarrativeStrategy));
+export default CategoryOutlierNarrativeStrategy;