@formant/ava 3.4.1-formant

package/lib/insight/narrative/strategy/timeSeriesOutlier.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var lodash_1 = require("lodash");
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var helpers_1 = require("./helpers");
+var variableMetaMap = {
+    dateRange: {
+        varType: 'time_desc',
+    },
+    measure: {
+        varType: 'metric_name',
+    },
+    max: {
+        varType: 'metric_value',
+    },
+    min: {
+        varType: 'metric_value',
+    },
+    total: {
+        varType: 'metric_value',
+    },
+    '.x': {
+        varType: 'dim_value',
+    },
+    '.y': {
+        varType: 'metric_value',
+    },
+    '.base': {
+        varType: 'metric_value',
+    },
+    '.diff': {
+        varType: 'delta_value',
+    },
+};
+var TimeSeriesOutlierNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(TimeSeriesOutlierNarrativeStrategy, _super);
+    function TimeSeriesOutlierNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TimeSeriesOutlierNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns, data = insightInfo.data;
+        var _a = patterns[0], measure = _a.measure, dimension = _a.dimension;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: TimeSeriesOutlierNarrativeStrategy.structures[lang],
+            variable: {
+                dateRange: "".concat((0, lodash_1.first)(data)[dimension], "~").concat((0, lodash_1.last)(data)[dimension]),
+                total: patterns.length,
+                measure: measure,
+                max: (0, lodash_1.maxBy)(data, measure)[measure],
+                min: (0, lodash_1.minBy)(data, measure)[measure],
+                outliers: patterns.map(function (point) {
+                    var base = point.baselines[point.index];
+                    var diff = point.y - base;
+                    return tslib_1.__assign(tslib_1.__assign({}, point), { base: base, diffDesc: (0, helpers_1.getDiffDesc)(diff, lang), diff: diff });
+                }),
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    TimeSeriesOutlierNarrativeStrategy.insightType = 'time_series_outlier';
+    TimeSeriesOutlierNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '${dateRange}，${measure} 波动范围为最大值 ${max}, 最小值 ${min}，有 ${total} 个异常点，按超过基线大小排序如下：',
+                variableMetaMap: variableMetaMap,
+            },
+            {
+                template: '${.x}，${measure} 为 ${.y}, 相比基线（${.base}）${.diffDesc} ${.diff}。',
+                displayType: 'bullet',
+                bulletOrder: true,
+                useVariable: 'outliers',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'In ${dateRange}, ${measure} fluctuates within the range of ${max} to ${min}, with ${total} outliers, sorted by size above the baseline as follows.',
+                variableMetaMap: variableMetaMap,
+            },
+            {
+                template: '${.x}, ${measure} for ${.y}, compared to the baseline value ${.base}, ${.diffDesc} ${.diff}.',
+                displayType: 'bullet',
+                bulletOrder: true,
+                useVariable: 'outliers',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return TimeSeriesOutlierNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = TimeSeriesOutlierNarrativeStrategy;

package/lib/insight/narrative/strategy/trend.d.ts

@@ -0,0 +1,8 @@
+import { InsightNarrativeStrategy } from './base';
+import type { InsightType, Language, InsightInfo, TrendInfo } from '../../types';
+import type { ParagraphSpec, Structure } from '../../../ntv/types';
+export default class TrendNarrativeStrategy extends InsightNarrativeStrategy<TrendInfo> {
+    static readonly insightType: InsightType;
+    protected static structures: Record<Language, Structure[]>;
+    generateTextSpec(insightInfo: InsightInfo<TrendInfo>, lang: Language): ParagraphSpec[];
+}

package/lib/insight/narrative/strategy/trend.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var lodash_1 = require("lodash");
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var trendMapping = {
+    decreasing: '下降',
+    increasing: '上升',
+    'no trend': '无明显趋势。',
+};
+var variableMetaMap = {
+    dateRange: {
+        varType: 'time_desc',
+    },
+    trend: {
+        varType: 'trend_desc',
+    },
+    measure: {
+        varType: 'metric_name',
+    },
+};
+var TrendNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(TrendNarrativeStrategy, _super);
+    function TrendNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    TrendNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns, data = insightInfo.data;
+        var _a = patterns[0], dimension = _a.dimension, measure = _a.measure, trend = _a.trend;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: TrendNarrativeStrategy.structures[lang],
+            variable: {
+                dateRange: "".concat((0, lodash_1.first)(data)[dimension], "~").concat((0, lodash_1.last)(data)[dimension]),
+                measure: measure,
+                trend: lang === 'en-US' ? trend : trendMapping[trend],
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    TrendNarrativeStrategy.insightType = 'trend';
+    TrendNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '${dateRange}，${measure}${trend}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'In ${dateRange}, the ${measure} goes ${trend}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return TrendNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = TrendNarrativeStrategy;

package/lib/insight/pipeline/extract.d.ts

@@ -0,0 +1,13 @@
+import Heap from 'heap-js';
+import type { Datum, InsightOptions, Measure, Subspace, InsightInfo, PatternInfo, HomogeneousPatternInfo, DataProperty } from '../types';
+interface ReferenceInfo {
+    fieldPropsMap: Record<string, DataProperty>;
+    impactMeasureReferences: Record<string, number>;
+}
+export declare function extractInsightsFor1M1DCombination(data: Datum[], dimensions: string[], measures: Measure[], subspace: Subspace, referenceInfo: ReferenceInfo, options: InsightOptions): (InsightInfo<PatternInfo> | null)[][];
+export declare function extractInsightsForCorrelation(data: Datum[], dimensions: string[], measures: Measure[], subspace: Subspace, referenceInfo: ReferenceInfo, options: InsightOptions): InsightInfo<PatternInfo>[];
+/** recursive extraction in data subspace */
+export declare function extractInsightsFromSubspace(data: Datum[], dimensions: string[], measures: Measure[], subspace: Subspace, referenceInfo: ReferenceInfo, insightsHeap: Heap<InsightInfo<PatternInfo>>, homogeneousInsightsHeap: Heap<InsightInfo<HomogeneousPatternInfo>>, options: InsightOptions): (InsightInfo<PatternInfo> | null)[];
+/** insight subject enumeration in the data */
+export declare function enumerateInsights(data: Datum[], dimensions: string[], measures: Measure[], referenceInfo: ReferenceInfo, insightsHeap: Heap<InsightInfo<PatternInfo>>, metaInsightsHeap: Heap<InsightInfo<HomogeneousPatternInfo>>, options?: InsightOptions): void;
+export {};

package/lib/insight/pipeline/extract.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumerateInsights = exports.extractInsightsFromSubspace = exports.extractInsightsForCorrelation = exports.extractInsightsFor1M1DCombination = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var constant_1 = require("../constant");
+var insights_1 = require("../insights");
+var aggregate_1 = require("../utils/aggregate");
+var homogeneous_1 = require("../insights/extractors/homogeneous");
+var preprocess_1 = require("./preprocess");
+var util_1 = require("./util");
+/** calculate the Impact which reflects the importance of the subject of an insight against the entire dataset  */
+function computeSubspaceImpact(data, subspace, impactMeasureReferences, measures) {
+    if (!(measures === null || measures === void 0 ? void 0 : measures.length) || !subspace)
+        return 1;
+    var impactValues = measures.map(function (measure) {
+        var measureValue = (0, preprocess_1.calculateImpactValue)(data, measure);
+        var referenceKey = "".concat(measure.fieldName, "@").concat(measure.method);
+        var referenceValue = impactMeasureReferences[referenceKey];
+        return measureValue / referenceValue;
+    });
+    return Math.max.apply(Math, tslib_1.__spreadArray([], tslib_1.__read(impactValues), false));
+}
+/** extract patterns from a specific subject */
+function extractPatternsFromSubject(data, subjectInfo, fieldPropsMap, options) {
+    var measures = subjectInfo.measures, dimensions = subjectInfo.dimensions;
+    var enumInsightTypes = (options === null || options === void 0 ? void 0 : options.insightTypes) || constant_1.PATTERN_TYPES;
+    var patterns = {};
+    enumInsightTypes.forEach(function (insightType) {
+        var insightExtractorChecker = insights_1.ExtractorCheckers[insightType];
+        var isValid = true;
+        // Check whether the data requirements of the extractor are met
+        if (insightExtractorChecker) {
+            if ((0, lodash_1.isString)(insightExtractorChecker({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap })))
+                isValid = false;
+        }
+        if (isValid && insights_1.insightPatternsExtractor) {
+            var _a = options || {}, algorithmParameter = _a.algorithmParameter, dataProcessInfo = _a.dataProcessInfo;
+            var extractorOptions = {
+                algorithmParameter: algorithmParameter,
+                dataProcessInfo: dataProcessInfo,
+                // Validation has been done in method extractInsights
+                dataValidation: false,
+                // Select only significant insights
+                filterInsight: true,
+            };
+            var extractedPatterns = (0, insights_1.insightPatternsExtractor)({
+                data: data,
+                dimensions: dimensions.map(function (dim) { return ({ fieldName: dim }); }),
+                measures: measures,
+                insightType: insightType,
+                options: extractorOptions,
+            });
+            patterns[insightType] = extractedPatterns;
+        }
+        else {
+            patterns[insightType] = undefined;
+        }
+    });
+    return patterns;
+}
+function extractInsightsFor1M1DCombination(data, dimensions, measures, subspace, referenceInfo, options) {
+    var fieldPropsMap = referenceInfo.fieldPropsMap;
+    var insights = [];
+    dimensions.forEach(function (dimension) {
+        var _a, _b;
+        var insightsPerDim = [];
+        var isTimeField = (_b = (_a = fieldPropsMap[dimension]) === null || _a === void 0 ? void 0 : _a.levelOfMeasurements) === null || _b === void 0 ? void 0 : _b.includes('Time');
+        measures.forEach(function (measure) {
+            var childSubjectInfo = { dimensions: [dimension], subspace: subspace, measures: [measure] };
+            var aggregatedData = (0, aggregate_1.aggregate)(data, dimension, [measure], isTimeField);
+            var patterns = extractPatternsFromSubject(aggregatedData, childSubjectInfo, fieldPropsMap, options);
+            var patternsArray = (0, lodash_1.flatten)(Object.values(patterns).filter(function (item) { return (item === null || item === void 0 ? void 0 : item.length) > 0; })).sort(function (a, b) { return b.significance - a.significance; });
+            if (patternsArray.length) {
+                var insight = {
+                    subspace: subspace,
+                    dimensions: [
+                        {
+                            fieldName: dimension,
+                        },
+                    ],
+                    measures: [measure],
+                    patterns: patternsArray,
+                    data: aggregatedData,
+                    score: patternsArray[0].significance,
+                };
+                insightsPerDim.push(insight);
+            }
+            else {
+                insightsPerDim.push(null);
+            }
+        });
+        insights.push(insightsPerDim);
+    });
+    return insights;
+}
+exports.extractInsightsFor1M1DCombination = extractInsightsFor1M1DCombination;
+function extractInsightsForCorrelation(data, dimensions, measures, subspace, referenceInfo, options) {
+    var _a;
+    var fieldPropsMap = referenceInfo.fieldPropsMap;
+    var insights = [];
+    var measureNum = measures.length;
+    if (measureNum >= 2) {
+        for (var i = 0; i < measureNum - 1; i += 1) {
+            for (var j = i + 1; j < measureNum; j += 1) {
+                var childSubjectInfo = { dimensions: dimensions, subspace: subspace, measures: [measures[i], measures[j]] };
+                var patterns = extractPatternsFromSubject(data, childSubjectInfo, fieldPropsMap, tslib_1.__assign(tslib_1.__assign({}, options), { insightTypes: ['correlation'] }));
+                var patternsArray = (_a = patterns === null || patterns === void 0 ? void 0 : patterns.correlation) === null || _a === void 0 ? void 0 : _a.sort(function (a, b) { return b.significance - a.significance; });
+                if (patternsArray === null || patternsArray === void 0 ? void 0 : patternsArray.length) {
+                    var insight = {
+                        subspace: subspace,
+                        dimensions: dimensions.map(function (d) { return ({ fieldName: d }); }),
+                        measures: [measures[i], measures[j]],
+                        patterns: patternsArray,
+                        data: data,
+                        score: patternsArray[0].significance,
+                    };
+                    insights.push(insight);
+                }
+            }
+        }
+    }
+    return insights;
+}
+exports.extractInsightsForCorrelation = extractInsightsForCorrelation;
+/** recursive extraction in data subspace */
+function extractInsightsFromSubspace(data, dimensions, measures, subspace, referenceInfo, insightsHeap, homogeneousInsightsHeap, options) {
+    var _a, _b;
+    /** subspace pruning */
+    if (!(data === null || data === void 0 ? void 0 : data.length)) {
+        return [];
+    }
+    // calculate impact score
+    var impactMeasureReferences = referenceInfo.impactMeasureReferences, fieldPropsMap = referenceInfo.fieldPropsMap;
+    var subspaceImpact = computeSubspaceImpact(data, subspace, impactMeasureReferences, options === null || options === void 0 ? void 0 : options.impactMeasures);
+    // pruning1: check the subpace impact limit
+    if (subspaceImpact < constant_1.INSIGHT_SCORE_BENCHMARK) {
+        return [];
+    }
+    // pruning2: check if the impact score is greater than the minimum score in heap
+    var impactScoreWeight = !!(options === null || options === void 0 ? void 0 : options.impactWeight) && options.impactWeight >= 0 && options.impactWeight < 1
+        ? options.impactWeight
+        : constant_1.IMPACT_SCORE_WEIGHT;
+    var optimalScore = subspaceImpact * impactScoreWeight + 1 * (1 - impactScoreWeight);
+    if (insightsHeap.length >= insightsHeap.limit) {
+        var minScoreInHeap = (_a = insightsHeap.peek()) === null || _a === void 0 ? void 0 : _a.score;
+        if (optimalScore <= minScoreInHeap) {
+            return [];
+        }
+    }
+    /** insight extraction */
+    var insights = [];
+    /** Combination: 1M * 1D */
+    var insightsFor1M1DCombination = extractInsightsFor1M1DCombination(data, dimensions, measures, subspace, referenceInfo, options);
+    insightsFor1M1DCombination.forEach(function (insightsPerDim) {
+        var insightsForMeasures = insightsPerDim
+            .filter(function (item) { return !!item; })
+            .map(function (item) { return (tslib_1.__assign(tslib_1.__assign({}, item), { score: item.score * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight })); });
+        insights.push.apply(insights, tslib_1.__spreadArray([], tslib_1.__read(insightsPerDim), false));
+        (0, util_1.addInsightsToHeap)(insightsForMeasures, insightsHeap);
+    });
+    // Combination 3: 1M * 1M */
+    if ((options.insightTypes || constant_1.PATTERN_TYPES).includes('correlation')) {
+        var extracted = extractInsightsForCorrelation(data, dimensions, measures, subspace, referenceInfo, options);
+        var insightsForCorrelation = extracted === null || extracted === void 0 ? void 0 : extracted.map(function (item) { return (tslib_1.__assign(tslib_1.__assign({}, item), { score: item.score * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight })); });
+        (0, util_1.addInsightsToHeap)(insightsForCorrelation, insightsHeap);
+    }
+    /**  extract homogeneous insight in measures */
+    if (options === null || options === void 0 ? void 0 : options.homogeneous) {
+        insightsFor1M1DCombination.forEach(function (insightsPerDim, dimIndex) {
+            var homogeneousPatternsForMeasures = (0, homogeneous_1.extractHomogeneousPatternsForMeasures)(measures, insightsPerDim);
+            if (homogeneousPatternsForMeasures.length > 0) {
+                var homogeneousInsights = homogeneousPatternsForMeasures.map(function (pattern) { return ({
+                    subspace: subspace,
+                    dimensions: [{ fieldName: dimensions[dimIndex] }],
+                    measures: measures,
+                    patterns: [pattern],
+                    data: data,
+                    score: pattern.significance * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight,
+                }); });
+                homogeneousInsightsHeap.addAll(homogeneousInsights);
+            }
+        });
+    }
+    /** subspace search */
+    if (!(options === null || options === void 0 ? void 0 : options.ignoreSubspace)) {
+        var searchedDimensions_1 = subspace.map(function (item) { return item.dimension; });
+        var remainDimensionFields_1 = (((_b = options === null || options === void 0 ? void 0 : options.dimensions) === null || _b === void 0 ? void 0 : _b.map(function (dimension) { return dimension.fieldName; })) ||
+            Object.values(fieldPropsMap)
+                .filter(function (item) { return item.domainType === 'dimension'; })
+                .map(function (item) { return item.name; })).filter(function (field) { return !searchedDimensions_1.includes(field); });
+        if (remainDimensionFields_1.length > 0) {
+            remainDimensionFields_1.forEach(function (dimension) {
+                var siblingGroupInsights = [];
+                var groupedData = (0, lodash_1.groupBy)(data, dimension);
+                var breakdownValues = (0, lodash_1.uniq)(fieldPropsMap[dimension].rawData);
+                var dimensionsInSubspace = remainDimensionFields_1.filter(function (item) { return item !== dimension; });
+                if (breakdownValues.length > 1) {
+                    breakdownValues.forEach(function (value) {
+                        var childSubspace = tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(subspace), false), [{ dimension: dimension, value: value }], false);
+                        var subspaceInsights = extractInsightsFromSubspace(groupedData[value], dimensionsInSubspace, measures, childSubspace, referenceInfo, insightsHeap, homogeneousInsightsHeap, options);
+                        siblingGroupInsights.push(subspaceInsights);
+                    });
+                }
+                /** extract homegenehous insight in sibling group */
+                if (options === null || options === void 0 ? void 0 : options.homogeneous) {
+                    dimensionsInSubspace.forEach(function (dim) {
+                        measures.forEach(function (measure) {
+                            var siblingGroupInsightsArr = siblingGroupInsights.map(function (siblingItem) {
+                                return (siblingItem.find(function (insight) {
+                                    return (!!insight &&
+                                        insight.dimensions.length === 1 &&
+                                        insight.dimensions[0].fieldName === dim &&
+                                        insight.measures.length === 1 &&
+                                        insight.measures[0].fieldName === measure.fieldName);
+                                }) || null);
+                            });
+                            var homogeneousPatternsForSiblingGroups = (0, homogeneous_1.extractHomogeneousPatternsForSiblingGroups)(breakdownValues, siblingGroupInsightsArr);
+                            var insightsForSiblingGroup = homogeneousPatternsForSiblingGroups.map(function (pattern) { return ({
+                                subspace: subspace,
+                                dimensions: [{ fieldName: dimension }, { fieldName: dim }],
+                                measures: [measure],
+                                patterns: [pattern],
+                                data: data,
+                                score: pattern.significance * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight,
+                            }); });
+                            homogeneousInsightsHeap.addAll(insightsForSiblingGroup);
+                        });
+                    });
+                }
+            });
+        }
+    }
+    return insights;
+}
+exports.extractInsightsFromSubspace = extractInsightsFromSubspace;
+/** insight subject enumeration in the data */
+function enumerateInsights(data, dimensions, measures, referenceInfo, insightsHeap, metaInsightsHeap, options) {
+    if (options === void 0) { options = {}; }
+    var initSubspace = [];
+    extractInsightsFromSubspace(data, dimensions, measures, initSubspace, referenceInfo, insightsHeap, metaInsightsHeap, options);
+}
+exports.enumerateInsights = enumerateInsights;

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

@@ -0,0 +1,2 @@
+import type { Datum, InsightOptions, InsightsResult } from '../types';
+export declare function getInsights(sourceData: Datum[], options?: InsightOptions): InsightsResult;

package/lib/insight/pipeline/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInsights = void 0;
+var tslib_1 = require("tslib");
+var insight_1 = require("./insight");
+function getInsights(sourceData, options) {
+    var extractResult = (0, insight_1.extractInsights)(sourceData, options);
+    if (options === null || options === void 0 ? void 0 : options.visualization) {
+        // Provide all vis options
+        var visOption = tslib_1.__assign({ lang: 'en-US' }, ((options === null || options === void 0 ? void 0 : options.visualization) === true ? {} : options === null || options === void 0 ? void 0 : options.visualization));
+        return (0, insight_1.generateInsightsWithVisualizationSpec)(extractResult, tslib_1.__assign(tslib_1.__assign({}, options), { visualization: visOption }));
+    }
+    return extractResult;
+}
+exports.getInsights = getInsights;

package/lib/insight/pipeline/insight.d.ts

@@ -0,0 +1,10 @@
+import type { Datum, InsightOptions, InsightInfo, PatternInfo, HomogeneousPatternInfo, InsightVisualizationOptions } from '../types';
+type InsightsResult = {
+    insights: InsightInfo<PatternInfo>[];
+    homogeneousInsights?: InsightInfo<HomogeneousPatternInfo>[];
+};
+export declare function extractInsights(sourceData: Datum[], options?: InsightOptions): InsightsResult;
+export declare function generateInsightsWithVisualizationSpec(extraction: InsightsResult, options?: InsightOptions & {
+    visualization: InsightVisualizationOptions;
+}): InsightsResult;
+export {};

package/lib/insight/pipeline/insight.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateInsightsWithVisualizationSpec = exports.extractInsights = void 0;
+var tslib_1 = require("tslib");
+var heap_js_1 = tslib_1.__importDefault(require("heap-js"));
+var constant_1 = require("../constant");
+var aggregate_1 = require("../utils/aggregate");
+var extract_1 = require("./extract");
+var preprocess_1 = require("./preprocess");
+var visualize_1 = require("./visualize");
+var util_1 = require("./util");
+function extractInsights(sourceData, options) {
+    var _a;
+    // get data columns infomations (column type, statistics, etc.)
+    var data = sourceData.filter(function (item) { return !Object.values(item).some(function (v) { return v === null || v === undefined; }); });
+    var dataProps = (0, preprocess_1.dataToDataProps)(data, options === null || options === void 0 ? void 0 : options.dataProcessInfo);
+    var fieldPropsMap = dataProps.reduce(function (acc, item) {
+        acc[item.name] = item;
+        return acc;
+    }, {});
+    var impactMeasureReferences = (0, preprocess_1.calculateImpactMeasureReferenceValues)(data, options === null || options === void 0 ? void 0 : options.impactMeasures);
+    var referenceInfo = {
+        fieldPropsMap: fieldPropsMap,
+        impactMeasureReferences: impactMeasureReferences,
+    };
+    var measures = (options === null || options === void 0 ? void 0 : options.measures) ||
+        dataProps
+            .filter(function (item) { return item.domainType === 'measure'; })
+            .map(function (item) { return ({
+            fieldName: item.name,
+            method: 'SUM',
+        }); });
+    var dimensions = ((_a = options === null || options === void 0 ? void 0 : options.dimensions) === null || _a === void 0 ? void 0 : _a.map(function (dimension) { return dimension.fieldName; })) ||
+        dataProps.filter(function (item) { return item.domainType === 'dimension'; }).map(function (item) { return item.name; });
+    // init insights storage
+    var insightsHeap = new heap_js_1.default(util_1.insightPriorityComparator);
+    var homogeneousInsightsHeap = new heap_js_1.default(util_1.homogeneousInsightPriorityComparator);
+    var insightsLimit = (options === null || options === void 0 ? void 0 : options.limit) || constant_1.INSIGHT_DEFAULT_LIMIT;
+    insightsHeap.limit = insightsLimit;
+    insightsHeap.init([]);
+    homogeneousInsightsHeap.init([]);
+    (0, extract_1.enumerateInsights)(data, dimensions, measures, referenceInfo, insightsHeap, homogeneousInsightsHeap, options);
+    // get top N results
+    var insights = [];
+    var heapSize = insightsHeap.size();
+    var insightsSize = heapSize > insightsLimit ? insightsLimit : heapSize;
+    for (var i = 0; i < insightsSize; i += 1) {
+        var top_1 = insightsHeap.pop();
+        insights.push(top_1);
+    }
+    var result = { insights: insights.reverse() };
+    if (options === null || options === void 0 ? void 0 : options.homogeneous) {
+        var homogeneousInsightsResult = [];
+        var homogeneousHeapSize = homogeneousInsightsHeap.size();
+        var homogeneousInsightsSize = homogeneousHeapSize > insightsLimit ? insightsLimit : homogeneousHeapSize;
+        for (var i = 0; i < homogeneousInsightsSize; i += 1) {
+            var top_2 = homogeneousInsightsHeap.pop();
+            homogeneousInsightsResult.push(top_2);
+        }
+        result.homogeneousInsights = homogeneousInsightsResult.reverse();
+    }
+    return result;
+}
+exports.extractInsights = extractInsights;
+function generateInsightsWithVisualizationSpec(extraction, options) {
+    var insights = extraction.insights, homogeneousInsights = extraction.homogeneousInsights;
+    var insightsWithVis = insights.map(function (item) { return (tslib_1.__assign(tslib_1.__assign({}, item), { visualizationSpecs: (0, visualize_1.generateInsightVisualizationSpec)(item, options === null || options === void 0 ? void 0 : options.visualization) })); });
+    var result = { insights: insightsWithVis };
+    if (homogeneousInsights && (options === null || options === void 0 ? void 0 : options.homogeneous)) {
+        var homogeneousInsightsWithVis = homogeneousInsights.map(function (item) {
+            var visualizationSpecs = (0, visualize_1.generateHomogeneousInsightVisualizationSpec)(item, options.visualization);
+            var data = item.data, measures = item.measures, dimensions = item.dimensions;
+            var insight = tslib_1.__assign(tslib_1.__assign({}, item), { visualizationSpecs: visualizationSpecs });
+            if (measures.length > 1) {
+                insight.data = (0, aggregate_1.aggregateWithMeasures)(data, dimensions[0].fieldName, measures);
+            }
+            else {
+                insight.data = (0, aggregate_1.aggregateWithSeries)(data, dimensions[0].fieldName, measures[0], dimensions[1].fieldName);
+            }
+            return insight;
+        });
+        result.homogeneousInsights = homogeneousInsightsWithVis;
+    }
+    return result;
+}
+exports.generateInsightsWithVisualizationSpec = generateInsightsWithVisualizationSpec;

package/lib/insight/pipeline/preprocess.d.ts

@@ -0,0 +1,6 @@
+import { Extra } from '../../data';
+import type { Datum, ImpactMeasure, DataProperty } from '../types';
+export declare function dataToDataProps(data: Datum[], extra?: Extra): DataProperty[];
+export declare function calculateImpactValue(data: Datum[], measure: ImpactMeasure): number;
+/** calculate the reference values for impact measures  */
+export declare function calculateImpactMeasureReferenceValues(data: Datum[], measures?: ImpactMeasure[]): Record<string, number>;

package/lib/insight/pipeline/preprocess.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateImpactMeasureReferenceValues = exports.calculateImpactValue = exports.dataToDataProps = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var data_1 = require("../../data");
+var aggregate_1 = require("../utils/aggregate");
+function dataToDataProps(data, extra) {
+    if (!data) {
+        throw new Error('Argument `data` is missing.');
+    }
+    var df = new data_1.DataFrame(data, extra);
+    var dataTypeInfos = df.info();
+    var dataProps = [];
+    dataTypeInfos.forEach(function (info) {
+        var _a;
+        var newInfo = tslib_1.__assign(tslib_1.__assign({}, info), { domainType: ((_a = (0, lodash_1.intersection)(['Interval', 'Continuous'], info.levelOfMeasurements)) === null || _a === void 0 ? void 0 : _a.length) ? 'measure' : 'dimension' });
+        dataProps.push(newInfo);
+    });
+    return dataProps;
+}
+exports.dataToDataProps = dataToDataProps;
+function calculateImpactValue(data, measure) {
+    var measureAggregator = aggregate_1.AggregatorMap[measure.method];
+    var value = measureAggregator(data, measure.fieldName);
+    return value;
+}
+exports.calculateImpactValue = calculateImpactValue;
+/** calculate the reference values for impact measures  */
+function calculateImpactMeasureReferenceValues(data, measures) {
+    var referenceMap = {};
+    measures === null || measures === void 0 ? void 0 : measures.forEach(function (measure) {
+        var measureKey = "".concat(measure.fieldName, "@").concat(measure.method);
+        var value = calculateImpactValue(data, measure);
+        referenceMap[measureKey] = value;
+    });
+    return referenceMap;
+}
+exports.calculateImpactMeasureReferenceValues = calculateImpactMeasureReferenceValues;

package/lib/insight/pipeline/specificInsight.d.ts

@@ -0,0 +1,11 @@
+import { G2Spec } from '@antv/g2';
+import { AugmentedMarks } from '../chart';
+import { InsightInfo, InsightType, PatternInfo, PatternInfo2InsightInfoProps, SpecificInsightProps, SpecificInsightResult } from '../types';
+export declare const patternInfo2InsightInfo: (props: PatternInfo2InsightInfoProps) => InsightInfo<PatternInfo>;
+export declare const getAnnotationSpec: (insightInfo: InsightInfo<PatternInfo>) => AugmentedMarks;
+export declare const getChartSpecWithoutAugmentedMarks: (insightInfo: InsightInfo<PatternInfo>, insightType: InsightType) => G2Spec;
+export declare const filterValidInsightInfoForAnnotationSpec: ({ patternInfos, insightType, }: {
+    patternInfos: PatternInfo[];
+    insightType: InsightType;
+}) => PatternInfo[];
+export declare const getSpecificInsight: (props: SpecificInsightProps) => SpecificInsightResult;