@formant/ava 3.4.1-formant

package/esm/insight/pipeline/extract.js

@@ -0,0 +1,236 @@
+import { __assign, __read, __spreadArray } from "tslib";
+import { groupBy, uniq, flatten, isString } from 'lodash';
+import { PATTERN_TYPES, INSIGHT_SCORE_BENCHMARK, IMPACT_SCORE_WEIGHT } from '../constant';
+import { insightPatternsExtractor, ExtractorCheckers } from '../insights';
+import { aggregate } from '../utils/aggregate';
+import { extractHomogeneousPatternsForMeasures, extractHomogeneousPatternsForSiblingGroups, } from '../insights/extractors/homogeneous';
+import { calculateImpactValue } from './preprocess';
+import { addInsightsToHeap } from './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 = calculateImpactValue(data, measure);
+        var referenceKey = "".concat(measure.fieldName, "@").concat(measure.method);
+        var referenceValue = impactMeasureReferences[referenceKey];
+        return measureValue / referenceValue;
+    });
+    return Math.max.apply(Math, __spreadArray([], __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) || PATTERN_TYPES;
+    var patterns = {};
+    enumInsightTypes.forEach(function (insightType) {
+        var insightExtractorChecker = ExtractorCheckers[insightType];
+        var isValid = true;
+        // Check whether the data requirements of the extractor are met
+        if (insightExtractorChecker) {
+            if (isString(insightExtractorChecker({ data: data, subjectInfo: subjectInfo, fieldPropsMap: fieldPropsMap })))
+                isValid = false;
+        }
+        if (isValid && 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 = 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;
+}
+export 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 = aggregate(data, dimension, [measure], isTimeField);
+            var patterns = extractPatternsFromSubject(aggregatedData, childSubjectInfo, fieldPropsMap, options);
+            var patternsArray = 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;
+}
+export 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, __assign(__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;
+}
+/** recursive extraction in data subspace */
+export 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 < 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
+        : 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 (__assign(__assign({}, item), { score: item.score * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight })); });
+        insights.push.apply(insights, __spreadArray([], __read(insightsPerDim), false));
+        addInsightsToHeap(insightsForMeasures, insightsHeap);
+    });
+    // Combination 3: 1M * 1M */
+    if ((options.insightTypes || 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 (__assign(__assign({}, item), { score: item.score * (1 - impactScoreWeight) + subspaceImpact * impactScoreWeight })); });
+        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 = 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 = groupBy(data, dimension);
+                var breakdownValues = uniq(fieldPropsMap[dimension].rawData);
+                var dimensionsInSubspace = remainDimensionFields_1.filter(function (item) { return item !== dimension; });
+                if (breakdownValues.length > 1) {
+                    breakdownValues.forEach(function (value) {
+                        var childSubspace = __spreadArray(__spreadArray([], __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 = 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;
+}
+/** insight subject enumeration in the data */
+export 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);
+}

package/esm/insight/pipeline/index.js

@@ -0,0 +1,11 @@
+import { __assign } from "tslib";
+import { extractInsights, generateInsightsWithVisualizationSpec } from './insight';
+export function getInsights(sourceData, options) {
+    var extractResult = extractInsights(sourceData, options);
+    if (options === null || options === void 0 ? void 0 : options.visualization) {
+        // Provide all vis options
+        var visOption = __assign({ lang: 'en-US' }, ((options === null || options === void 0 ? void 0 : options.visualization) === true ? {} : options === null || options === void 0 ? void 0 : options.visualization));
+        return generateInsightsWithVisualizationSpec(extractResult, __assign(__assign({}, options), { visualization: visOption }));
+    }
+    return extractResult;
+}

package/esm/insight/pipeline/insight.js

@@ -0,0 +1,81 @@
+import { __assign } from "tslib";
+import Heap from 'heap-js';
+import { INSIGHT_DEFAULT_LIMIT } from '../constant';
+import { aggregateWithSeries, aggregateWithMeasures } from '../utils/aggregate';
+import { enumerateInsights } from './extract';
+import { dataToDataProps, calculateImpactMeasureReferenceValues } from './preprocess';
+import { generateHomogeneousInsightVisualizationSpec, generateInsightVisualizationSpec } from './visualize';
+import { insightPriorityComparator, homogeneousInsightPriorityComparator } from './util';
+export 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 = 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 = 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(insightPriorityComparator);
+    var homogeneousInsightsHeap = new Heap(homogeneousInsightPriorityComparator);
+    var insightsLimit = (options === null || options === void 0 ? void 0 : options.limit) || INSIGHT_DEFAULT_LIMIT;
+    insightsHeap.limit = insightsLimit;
+    insightsHeap.init([]);
+    homogeneousInsightsHeap.init([]);
+    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;
+}
+export function generateInsightsWithVisualizationSpec(extraction, options) {
+    var insights = extraction.insights, homogeneousInsights = extraction.homogeneousInsights;
+    var insightsWithVis = insights.map(function (item) { return (__assign(__assign({}, item), { visualizationSpecs: 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 = generateHomogeneousInsightVisualizationSpec(item, options.visualization);
+            var data = item.data, measures = item.measures, dimensions = item.dimensions;
+            var insight = __assign(__assign({}, item), { visualizationSpecs: visualizationSpecs });
+            if (measures.length > 1) {
+                insight.data = aggregateWithMeasures(data, dimensions[0].fieldName, measures);
+            }
+            else {
+                insight.data = aggregateWithSeries(data, dimensions[0].fieldName, measures[0], dimensions[1].fieldName);
+            }
+            return insight;
+        });
+        result.homogeneousInsights = homogeneousInsightsWithVis;
+    }
+    return result;
+}

package/esm/insight/pipeline/preprocess.js

@@ -0,0 +1,33 @@
+import { __assign } from "tslib";
+import { intersection } from 'lodash';
+import { DataFrame } from '../../data';
+import { AggregatorMap } from '../utils/aggregate';
+export function dataToDataProps(data, extra) {
+    if (!data) {
+        throw new Error('Argument `data` is missing.');
+    }
+    var df = new DataFrame(data, extra);
+    var dataTypeInfos = df.info();
+    var dataProps = [];
+    dataTypeInfos.forEach(function (info) {
+        var _a;
+        var newInfo = __assign(__assign({}, info), { domainType: ((_a = intersection(['Interval', 'Continuous'], info.levelOfMeasurements)) === null || _a === void 0 ? void 0 : _a.length) ? 'measure' : 'dimension' });
+        dataProps.push(newInfo);
+    });
+    return dataProps;
+}
+export function calculateImpactValue(data, measure) {
+    var measureAggregator = AggregatorMap[measure.method];
+    var value = measureAggregator(data, measure.fieldName);
+    return value;
+}
+/** calculate the reference values for impact measures  */
+export 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;
+}

package/esm/insight/pipeline/specificInsight.js

@@ -0,0 +1,71 @@
+import { __assign } from "tslib";
+import { size } from 'lodash';
+import { generateInsightChartSpec, changePointAugmentedMarksStrategy, trendAugmentedMarksStrategy, timeSeriesOutlierStrategyAugmentedMarksStrategy, lowVarianceAugmentedMarkStrategy, categoryOutlierAugmentedMarksStrategy, } from '../chart';
+import { insightPatternsExtractor } from '../insights';
+import generateInsightNarrative from '../narrative';
+import { pickValidPattern, pickValidTimeSeriesOutlierPatterns } from '../insights/util';
+import { insight2ChartStrategy, viewSpecStrategy } from '../chart/strategy';
+export var patternInfo2InsightInfo = function (props) {
+    var dimensions = props.dimensions, measures = props.measures, data = props.data, patternInfos = props.patternInfos;
+    return {
+        subspace: [],
+        dimensions: dimensions,
+        measures: measures,
+        patterns: patternInfos,
+        data: data,
+    };
+};
+export var getAnnotationSpec = function (insightInfo) {
+    var _a, _b;
+    var insightType = ((_a = insightInfo.patterns[0]) !== null && _a !== void 0 ? _a : {}).type;
+    var insightType2AugmentedMarks = {
+        trend: trendAugmentedMarksStrategy,
+        change_point: changePointAugmentedMarksStrategy,
+        time_series_outlier: timeSeriesOutlierStrategyAugmentedMarksStrategy,
+        low_variance: lowVarianceAugmentedMarkStrategy,
+        category_outlier: categoryOutlierAugmentedMarksStrategy,
+    };
+    return (_b = insightType2AugmentedMarks[insightType]) === null || _b === void 0 ? void 0 : _b.call(insightType2AugmentedMarks, insightInfo);
+};
+export var getChartSpecWithoutAugmentedMarks = function (insightInfo, insightType) {
+    var chartMark = insight2ChartStrategy(__assign(__assign({}, insightInfo), (size(insightInfo.patterns) === 0
+        ? {
+            patterns: [{ type: insightType }],
+        }
+        : {})));
+    return viewSpecStrategy([chartMark], insightInfo);
+};
+export var filterValidInsightInfoForAnnotationSpec = function (_a) {
+    var _b = _a.patternInfos, patternInfos = _b === void 0 ? [] : _b, insightType = _a.insightType;
+    if (insightType === 'time_series_outlier')
+        return pickValidTimeSeriesOutlierPatterns(patternInfos);
+    return pickValidPattern(patternInfos);
+};
+export var getSpecificInsight = function (props) {
+    var _a = props.options, options = _a === void 0 ? {} : _a, insightType = props.insightType;
+    var _b = options.visualizationOptions, visualizationOptions = _b === void 0 ? { lang: 'zh-CN' } : _b;
+    var patternInfos = insightPatternsExtractor(props);
+    var validPatternInfos = filterValidInsightInfoForAnnotationSpec({ patternInfos: patternInfos, insightType: insightType });
+    var totalInsightInfo = patternInfo2InsightInfo(__assign(__assign({}, props), { patternInfos: patternInfos }));
+    if (size(validPatternInfos)) {
+        var validInsightInfo = patternInfo2InsightInfo(__assign(__assign({}, props), { patternInfos: validPatternInfos }));
+        var annotationSpec = getAnnotationSpec(validInsightInfo);
+        var chartSpec_1 = generateInsightChartSpec(validInsightInfo);
+        var narrativeSpec = generateInsightNarrative(validInsightInfo, visualizationOptions);
+        return __assign(__assign({}, totalInsightInfo), { visualizationSpecs: [
+                {
+                    annotationSpec: annotationSpec,
+                    chartSpec: chartSpec_1,
+                    patternType: insightType,
+                    narrativeSpec: narrativeSpec,
+                },
+            ] });
+    }
+    var chartSpec = getChartSpecWithoutAugmentedMarks(totalInsightInfo, insightType);
+    return __assign(__assign({}, totalInsightInfo), { visualizationSpecs: [
+            {
+                chartSpec: chartSpec,
+                patternType: insightType,
+            },
+        ] });
+};

package/esm/insight/pipeline/util.js

@@ -0,0 +1,14 @@
+export var insightPriorityComparator = function (a, b) {
+    return a.score - b.score;
+};
+export var homogeneousInsightPriorityComparator = function (a, b) { return a.score - b.score; };
+export function addInsightsToHeap(insights, heap) {
+    insights === null || insights === void 0 ? void 0 : insights.forEach(function (item) {
+        if (heap.length >= heap.limit) {
+            heap.pushpop(item);
+        }
+        else {
+            heap.add(item);
+        }
+    });
+}

package/esm/insight/pipeline/visualize.js

@@ -0,0 +1,41 @@
+import { __assign, __read } from "tslib";
+import { groupBy, omit } from 'lodash';
+import generateInsightNarrative from '../narrative';
+import { generateInsightChartSpec } from '../chart';
+export var generateInsightVisualizationSpec = function (insight, visualizationOptions) {
+    if (visualizationOptions === void 0) { visualizationOptions = {
+        lang: 'en-US',
+    }; }
+    var patterns = insight.patterns;
+    var specs = [];
+    if (!patterns.length)
+        return [];
+    var patternGroups = groupBy(patterns, function (pattern) { return pattern.type; });
+    Object.entries(patternGroups).forEach(function (_a) {
+        var _b = __read(_a, 2), patternType = _b[0], patternGroup = _b[1];
+        var chartSpec = generateInsightChartSpec(__assign(__assign({}, insight), { patterns: patternGroup }));
+        specs.push({
+            patternType: patternType,
+            chartSpec: chartSpec,
+            narrativeSpec: generateInsightNarrative(__assign(__assign({}, insight), { patterns: patternGroup }), visualizationOptions),
+        });
+    });
+    return specs;
+};
+export var generateHomogeneousInsightVisualizationSpec = function (insight, visualizationOptions) {
+    if (visualizationOptions === void 0) { visualizationOptions = {
+        lang: 'en-US',
+    }; }
+    var patterns = insight.patterns;
+    var schemas = [];
+    patterns.forEach(function (pattern) {
+        var insightType = pattern.insightType;
+        var chartSpec = {};
+        schemas.push({
+            patternType: insightType,
+            chartSpec: chartSpec,
+            narrativeSpec: generateInsightNarrative(__assign(__assign({}, omit(insight, ['patterns'])), pattern), visualizationOptions),
+        });
+    });
+    return schemas;
+};

package/esm/insight/types.js

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

package/esm/insight/utils/aggregate.js

@@ -0,0 +1,87 @@
+import { __assign, __read } from "tslib";
+import { groupBy, sumBy, minBy, maxBy, meanBy, sortBy, flatten, uniq } from 'lodash';
+var sum = function (data, measure) {
+    return sumBy(data, measure);
+};
+var count = function (data, measure) {
+    return data.filter(function (item) { return measure in item; }).length;
+};
+var countDistinct = function (data, measure) {
+    return uniq(data.filter(function (item) { return measure in item; }).map(function (item) { return item[measure]; })).length;
+};
+var max = function (data, measure) {
+    var _a;
+    return (_a = maxBy(data, measure)) === null || _a === void 0 ? void 0 : _a[measure];
+};
+var min = function (data, measure) {
+    var _a;
+    return (_a = minBy(data, measure)) === null || _a === void 0 ? void 0 : _a[measure];
+};
+var mean = function (data, measure) {
+    return meanBy(data, measure);
+};
+export var AggregatorMap = {
+    SUM: sum,
+    COUNT: count,
+    MAX: max,
+    MIN: min,
+    MEAN: mean,
+    COUNT_DISTINCT: countDistinct,
+};
+export function aggregate(data, groupByField, measures, sort) {
+    var grouped = groupBy(data, groupByField);
+    var entries = sort ? sortBy(Object.entries(grouped), '0') : Object.entries(grouped);
+    return entries.map(function (_a) {
+        var _b;
+        var _c = __read(_a, 2), value = _c[0], dataGroup = _c[1];
+        var datum = (_b = {}, _b[groupByField] = value, _b);
+        measures.forEach(function (measure) {
+            var measureField = measure.fieldName, method = measure.method;
+            var aggregator = AggregatorMap[method];
+            datum[measureField] = aggregator(dataGroup, measureField);
+        });
+        return datum;
+    });
+}
+export function aggregateWithMeasures(data, groupByField, measures) {
+    var grouped = groupBy(data, groupByField);
+    var result = [];
+    Object.entries(grouped).forEach(function (_a) {
+        var _b = __read(_a, 2), value = _b[0], dataGroup = _b[1];
+        measures.forEach(function (measure) {
+            var _a;
+            var measureField = measure.fieldName, method = measure.method;
+            if (measureField in dataGroup[0]) {
+                var aggregator = AggregatorMap[method];
+                var measureValue = aggregator(dataGroup, measureField);
+                result.push((_a = {},
+                    _a[groupByField] = value,
+                    _a.value = measureValue,
+                    _a.measureName = measureField,
+                    _a));
+            }
+        });
+    });
+    return result;
+}
+export function aggregateWithSeries(data, groupByField, measure, expandingField) {
+    var grouped = groupBy(data, groupByField);
+    var measureField = measure.fieldName, method = measure.method;
+    var aggregator = AggregatorMap[method];
+    return flatten(Object.entries(grouped).map(function (_a) {
+        var _b = __read(_a, 2), value = _b[0], dataGroup = _b[1];
+        var childGrouped = groupBy(dataGroup, expandingField);
+        var part = Object.entries(childGrouped).map(function (_a) {
+            var _b;
+            var _c = __read(_a, 2), childValue = _c[0], childDataGroup = _c[1];
+            return _b = {},
+                _b[expandingField] = childValue,
+                _b[measureField] = aggregator(childDataGroup, measureField),
+                _b;
+        });
+        return part.map(function (item) {
+            var _a;
+            return __assign(__assign({}, item), (_a = {}, _a[groupByField] = value, _a));
+        });
+    }));
+}

package/esm/insight/utils/common.js

@@ -0,0 +1,35 @@
+import { lastIndexOf } from 'lodash';
+// sign
+export function sign(value) {
+    if (value > 0)
+        return 1;
+    return value < 0 ? -1 : 0;
+}
+// unique
+export function unique(arr) {
+    var sorted = arr.slice().sort();
+    var uniqArr = [sorted[0]];
+    var countArr = [1];
+    for (var i = 1; i < sorted.length; i += 1) {
+        if (sorted[i] !== uniqArr[uniqArr.length - 1]) {
+            uniqArr.push(sorted[i]);
+            countArr.push(1);
+        }
+        else {
+            countArr[countArr.length - 1] += 1;
+        }
+    }
+    return [uniqArr, countArr];
+}
+// rank
+export function rank(arr) {
+    var sorted = arr.slice().sort();
+    var rank = [];
+    for (var i = 0; i < arr.length; i += 1) {
+        var value = arr[i];
+        var firstRank = sorted.indexOf(value) + 1;
+        var lastRank = lastIndexOf(sorted, value) + 1;
+        rank.push(firstRank === lastRank ? firstRank : (firstRank + lastRank) / 2);
+    }
+    return rank;
+}