@formant/ava 3.4.1-formant

package/lib/insight/pipeline/specificInsight.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecificInsight = exports.filterValidInsightInfoForAnnotationSpec = exports.getChartSpecWithoutAugmentedMarks = exports.getAnnotationSpec = exports.patternInfo2InsightInfo = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var chart_1 = require("../chart");
+var insights_1 = require("../insights");
+var narrative_1 = tslib_1.__importDefault(require("../narrative"));
+var util_1 = require("../insights/util");
+var strategy_1 = require("../chart/strategy");
+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,
+    };
+};
+exports.patternInfo2InsightInfo = patternInfo2InsightInfo;
+var getAnnotationSpec = function (insightInfo) {
+    var _a, _b;
+    var insightType = ((_a = insightInfo.patterns[0]) !== null && _a !== void 0 ? _a : {}).type;
+    var insightType2AugmentedMarks = {
+        trend: chart_1.trendAugmentedMarksStrategy,
+        change_point: chart_1.changePointAugmentedMarksStrategy,
+        time_series_outlier: chart_1.timeSeriesOutlierStrategyAugmentedMarksStrategy,
+        low_variance: chart_1.lowVarianceAugmentedMarkStrategy,
+        category_outlier: chart_1.categoryOutlierAugmentedMarksStrategy,
+    };
+    return (_b = insightType2AugmentedMarks[insightType]) === null || _b === void 0 ? void 0 : _b.call(insightType2AugmentedMarks, insightInfo);
+};
+exports.getAnnotationSpec = getAnnotationSpec;
+var getChartSpecWithoutAugmentedMarks = function (insightInfo, insightType) {
+    var chartMark = (0, strategy_1.insight2ChartStrategy)(tslib_1.__assign(tslib_1.__assign({}, insightInfo), ((0, lodash_1.size)(insightInfo.patterns) === 0
+        ? {
+            patterns: [{ type: insightType }],
+        }
+        : {})));
+    return (0, strategy_1.viewSpecStrategy)([chartMark], insightInfo);
+};
+exports.getChartSpecWithoutAugmentedMarks = getChartSpecWithoutAugmentedMarks;
+var filterValidInsightInfoForAnnotationSpec = function (_a) {
+    var _b = _a.patternInfos, patternInfos = _b === void 0 ? [] : _b, insightType = _a.insightType;
+    if (insightType === 'time_series_outlier')
+        return (0, util_1.pickValidTimeSeriesOutlierPatterns)(patternInfos);
+    return (0, util_1.pickValidPattern)(patternInfos);
+};
+exports.filterValidInsightInfoForAnnotationSpec = filterValidInsightInfoForAnnotationSpec;
+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 = (0, insights_1.insightPatternsExtractor)(props);
+    var validPatternInfos = (0, exports.filterValidInsightInfoForAnnotationSpec)({ patternInfos: patternInfos, insightType: insightType });
+    var totalInsightInfo = (0, exports.patternInfo2InsightInfo)(tslib_1.__assign(tslib_1.__assign({}, props), { patternInfos: patternInfos }));
+    if ((0, lodash_1.size)(validPatternInfos)) {
+        var validInsightInfo = (0, exports.patternInfo2InsightInfo)(tslib_1.__assign(tslib_1.__assign({}, props), { patternInfos: validPatternInfos }));
+        var annotationSpec = (0, exports.getAnnotationSpec)(validInsightInfo);
+        var chartSpec_1 = (0, chart_1.generateInsightChartSpec)(validInsightInfo);
+        var narrativeSpec = (0, narrative_1.default)(validInsightInfo, visualizationOptions);
+        return tslib_1.__assign(tslib_1.__assign({}, totalInsightInfo), { visualizationSpecs: [
+                {
+                    annotationSpec: annotationSpec,
+                    chartSpec: chartSpec_1,
+                    patternType: insightType,
+                    narrativeSpec: narrativeSpec,
+                },
+            ] });
+    }
+    var chartSpec = (0, exports.getChartSpecWithoutAugmentedMarks)(totalInsightInfo, insightType);
+    return tslib_1.__assign(tslib_1.__assign({}, totalInsightInfo), { visualizationSpecs: [
+            {
+                chartSpec: chartSpec,
+                patternType: insightType,
+            },
+        ] });
+};
+exports.getSpecificInsight = getSpecificInsight;

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

@@ -0,0 +1,5 @@
+import Heap from 'heap-js';
+import type { InsightInfo, PatternInfo, HomogeneousPatternInfo } from '../types';
+export declare const insightPriorityComparator: (a: InsightInfo<PatternInfo>, b: InsightInfo<PatternInfo>) => number;
+export declare const homogeneousInsightPriorityComparator: (a: InsightInfo<HomogeneousPatternInfo>, b: InsightInfo<HomogeneousPatternInfo>) => number;
+export declare function addInsightsToHeap(insights: InsightInfo<PatternInfo>[], heap: Heap<InsightInfo<PatternInfo>>): void;

package/lib/insight/pipeline/util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addInsightsToHeap = exports.homogeneousInsightPriorityComparator = exports.insightPriorityComparator = void 0;
+var insightPriorityComparator = function (a, b) {
+    return a.score - b.score;
+};
+exports.insightPriorityComparator = insightPriorityComparator;
+var homogeneousInsightPriorityComparator = function (a, b) { return a.score - b.score; };
+exports.homogeneousInsightPriorityComparator = homogeneousInsightPriorityComparator;
+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);
+        }
+    });
+}
+exports.addInsightsToHeap = addInsightsToHeap;

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

@@ -0,0 +1,3 @@
+import { HomogeneousPatternInfo, InsightInfo, PatternInfo, InsightVisualizationOptions, InsightVisualizationSpec } from '../types';
+export declare const generateInsightVisualizationSpec: (insight: InsightInfo<PatternInfo>, visualizationOptions?: InsightVisualizationOptions) => InsightVisualizationSpec[];
+export declare const generateHomogeneousInsightVisualizationSpec: (insight: InsightInfo<HomogeneousPatternInfo>, visualizationOptions?: InsightVisualizationOptions) => InsightVisualizationSpec[];

package/lib/insight/pipeline/visualize.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateHomogeneousInsightVisualizationSpec = exports.generateInsightVisualizationSpec = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var narrative_1 = tslib_1.__importDefault(require("../narrative"));
+var chart_1 = require("../chart");
+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 = (0, lodash_1.groupBy)(patterns, function (pattern) { return pattern.type; });
+    Object.entries(patternGroups).forEach(function (_a) {
+        var _b = tslib_1.__read(_a, 2), patternType = _b[0], patternGroup = _b[1];
+        var chartSpec = (0, chart_1.generateInsightChartSpec)(tslib_1.__assign(tslib_1.__assign({}, insight), { patterns: patternGroup }));
+        specs.push({
+            patternType: patternType,
+            chartSpec: chartSpec,
+            narrativeSpec: (0, narrative_1.default)(tslib_1.__assign(tslib_1.__assign({}, insight), { patterns: patternGroup }), visualizationOptions),
+        });
+    });
+    return specs;
+};
+exports.generateInsightVisualizationSpec = generateInsightVisualizationSpec;
+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: (0, narrative_1.default)(tslib_1.__assign(tslib_1.__assign({}, (0, lodash_1.omit)(insight, ['patterns'])), pattern), visualizationOptions),
+        });
+    });
+    return schemas;
+};
+exports.generateHomogeneousInsightVisualizationSpec = generateHomogeneousInsightVisualizationSpec;

package/lib/insight/types.d.ts

@@ -0,0 +1,238 @@
+import { PCorrTestParameter } from '../data/statistics/types';
+import { PATTERN_TYPES, HOMOGENEOUS_PATTERN_TYPES } from './constant';
+import { AugmentedMarks } from './chart/types';
+import type { G2Spec } from '@antv/g2';
+import type { ParagraphSpec } from '../ntv/types';
+import type { NumberFieldInfo, DateFieldInfo, StringFieldInfo, Extra } from '../data/types';
+export type Datum = Record<string, string | number>;
+export type DomainType = 'measure' | 'dimension';
+export type MeasureMethod = 'SUM' | 'COUNT' | 'MAX' | 'MIN' | 'MEAN' | 'COUNT_DISTINCT';
+export type ImpactMeasureMethod = 'SUM' | 'COUNT';
+export type Aggregator = (data: Datum[], measure: string) => number;
+/** output of data module, plus the field name and its domain type  */
+export type DataProperty = (NumberFieldInfo | DateFieldInfo | StringFieldInfo) & {
+    /** field name */
+    name: string;
+    /** whether this field is used as a dimension or measure */
+    domainType: DomainType;
+};
+export type Measure = {
+    /** use the field name as uniq key */
+    fieldName: string;
+    method: MeasureMethod;
+};
+export type Dimension = {
+    /** use the field name as uniq key */
+    fieldName: string;
+};
+export type Subspace = {
+    dimension: string;
+    value: string;
+}[];
+export type ImpactMeasure = {
+    fieldName: string;
+    method: ImpactMeasureMethod;
+};
+/**
+ * insight data subject information
+ */
+export interface SubjectInfo {
+    subspace: Subspace;
+    dimensions: string[];
+    measures: Measure[];
+}
+export type InsightType = (typeof PATTERN_TYPES)[number];
+export type HomogeneousInsightType = (typeof HOMOGENEOUS_PATTERN_TYPES)[number];
+/** insight chart type recommendation */
+export type ChartType = 'column_chart' | 'line_chart' | 'pie_chart' | 'scatter_plot';
+/** pattern information */
+export type PatternInfo = CategoryOutlierInfo | TimeSeriesOutlierInfo | LowVarianceInfo | TrendInfo | ChangePointInfo | CorrelationInfo | MajorityInfo;
+/** explanation and visualization for insight */
+export interface InsightVisualizationSpec {
+    patternType: InsightType;
+    chartSpec: G2Spec;
+    /** augmented marks */
+    annotationSpec?: AugmentedMarks;
+    /**
+     * @description explain insight by text
+     * @default ParagraphSpec[]
+     */
+    narrativeSpec?: ParagraphSpec[];
+}
+/** output insight information */
+export interface InsightInfo<T = PatternInfo> {
+    subspace: Subspace;
+    dimensions: Dimension[];
+    measures: Measure[];
+    score?: number;
+    data: Datum[];
+    patterns: T[];
+    visualizationSpecs?: InsightVisualizationSpec[];
+}
+export type Language = 'zh-CN' | 'en-US';
+/**
+ * config of visualization
+ */
+export type InsightVisualizationOptions = {
+    /**
+     * @description pure text or text specification to description insight summary
+     * @default 'text'
+     * */
+    /**
+     * @description explain insight use which language
+     * @default 'en-US'
+     * @experimental Using natural language to describe insights is an experimental feature and the output may be subject to change.
+     */
+    lang: Language;
+};
+export type LowVarianceParameter = {
+    /** Default value is 0.15  */
+    cvThreshold?: number;
+};
+export type MajorityParameter = {
+    /** Proportion greater than limit is considered as significant. Default value is 0.6 */
+    limit?: number;
+};
+export type OutlierParameter = {
+    /**
+     * - IQR: Inter Quartile Range method which is used by default. A point is considered an outlier when it lies outside of iqrK times the inter quartile range.
+     * - p-value: Assuming that the data follows a normal distribution, a point is considered an outlier if the two-sided test p-value is less than 1-confidenceInterval.
+     * */
+    method?: 'IQR' | 'p-value';
+    /** Parameter of Inter Quartile Range method. Default value is 1.5. */
+    iqrK?: number;
+    /** Parameter of p-value method. Default value is 0.95. */
+    confidenceInterval?: number;
+};
+export type CommonParameter = {
+    /** Significance level (alpha) in hypothesis testing */
+    threshold?: number;
+};
+/** Key parameters in the algorithm for extracting insights */
+export type AlgorithmParameter = {
+    /**
+     * Contains both category outlier and time series outlier
+     * */
+    outlier?: OutlierParameter;
+    /** time series trend, Default value of significance is 0.05 */
+    trend?: CommonParameter;
+    /** Significance level (alpha) in Bayesian online change point detection. Default value is 0.15 */
+    changePoint?: CommonParameter;
+    correlation?: PCorrTestParameter;
+    lowVariance?: LowVarianceParameter;
+    majority?: MajorityParameter;
+};
+export type InsightExtractorOptions = Pick<InsightOptions, 'algorithmParameter' | 'dataProcessInfo'> & {
+    /** Whether to filter non-significant insights. The default is false. */
+    filterInsight?: boolean;
+    /** Whether data length, type, etc. need to be verified. The default is false. */
+    dataValidation?: boolean;
+    visualizationOptions?: InsightVisualizationOptions;
+};
+export type InsightExtractorProps = {
+    data: Datum[];
+    dimensions: Dimension[];
+    measures: Measure[];
+    insightType: InsightType;
+    options?: InsightExtractorOptions;
+};
+export type PreValidationProps = Omit<InsightExtractorProps, 'algorithmParameter'>;
+export type GetPatternInfo<T = PatternInfo> = (props: InsightExtractorProps) => T[] | [NoPatternInfo];
+export type AlgorithmStandardInput = {
+    dimension: string;
+    measure: string;
+    values: number[];
+};
+/** custom options */
+export interface InsightOptions {
+    /** dimensions for analysis */
+    dimensions?: Dimension[];
+    /** measures for analysis */
+    measures?: Measure[];
+    /** Measures for Impact score */
+    impactMeasures?: ImpactMeasure[];
+    /** Insight score = Impact score * impactWeight + Significance * (1 - impactWeight) */
+    impactWeight?: number;
+    /** types of insight */
+    insightTypes?: InsightType[];
+    /** Limit on the number of insights */
+    limit?: number;
+    /** on / off the output of visualization scheme */
+    visualization?: boolean | Partial<InsightVisualizationOptions>;
+    /** on/off extra homogeneous insight extraction */
+    homogeneous?: boolean;
+    /** Whether to close the search for subspaces */
+    ignoreSubspace?: boolean;
+    /** Parameter passed through to the data frame during data pre-processing */
+    dataProcessInfo?: Extra;
+    /** Key parameters in the algorithm for extracting insights */
+    algorithmParameter?: AlgorithmParameter;
+}
+export interface BasePatternInfo<T extends InsightType> {
+    type: T;
+    significance: number;
+    /** Significant insight at the specified significance threshold */
+    significantInsight?: boolean;
+    info?: string;
+}
+export interface HomogeneousPatternInfo {
+    type: HomogeneousInsightType;
+    significance: number;
+    insightType: InsightType;
+    childPatterns: PatternInfo[];
+    /** dimension values that share same patterns */
+    commonSet: string[];
+    /** dimension values that do not share same patterns with others */
+    exceptions?: string[];
+}
+export type PointPatternInfo = {
+    index: number;
+    dimension: string;
+    measure: string;
+    x: string | number;
+    y: number;
+};
+export type TimeSeriesInfo = {
+    baselines: number[];
+    thresholds: [number, number];
+};
+export type CategoryOutlierInfo = BasePatternInfo<'category_outlier'> & PointPatternInfo;
+export type TimeSeriesOutlierInfo = BasePatternInfo<'time_series_outlier'> & PointPatternInfo & TimeSeriesInfo;
+export type ChangePointInfo = BasePatternInfo<'change_point'> & PointPatternInfo;
+export type MajorityInfo = BasePatternInfo<'majority'> & PointPatternInfo & {
+    proportion: number;
+};
+export type TrendType = 'decreasing' | 'increasing' | 'no trend';
+export interface LinearRegressionResult {
+    r2: number;
+    points: number[];
+    equation: [m: number, c: number];
+}
+export type TrendInfo = BasePatternInfo<'trend'> & {
+    trend: TrendType;
+    regression: LinearRegressionResult;
+    dimension: string;
+    measure: string;
+};
+export type LowVarianceInfo = BasePatternInfo<'low_variance'> & {
+    dimension: string;
+    measure: string;
+    mean: number;
+};
+export type CorrelationInfo = BasePatternInfo<'correlation'> & {
+    pcorr: number;
+    measures: [string, string];
+};
+export type NoPatternInfo = BasePatternInfo<InsightType> & {
+    info: string;
+    [key: string]: any;
+};
+export type InsightsResult = {
+    insights: InsightInfo<PatternInfo>[];
+    homogeneousInsights?: InsightInfo<HomogeneousPatternInfo>[];
+};
+export type SpecificInsightProps = InsightExtractorProps;
+export type SpecificInsightResult = Required<Omit<InsightInfo<PatternInfo>, 'score'>>;
+export type PatternInfo2InsightInfoProps = SpecificInsightProps & {
+    patternInfos: PatternInfo[];
+};

package/lib/insight/types.js

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

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

@@ -0,0 +1,7 @@
+import { Aggregator, Datum, Measure, MeasureMethod } from '../types';
+export declare const AggregatorMap: Record<MeasureMethod, Aggregator>;
+export declare function aggregate(data: Datum[], groupByField: string, measures: Measure[], sort?: boolean): Datum[];
+export declare function aggregateWithMeasures(data: Datum[], groupByField: string, measures: Measure[]): Datum[];
+export declare function aggregateWithSeries(data: Datum[], groupByField: string, measure: Measure, expandingField: string): {
+    [x: string]: string | number;
+}[];

package/lib/insight/utils/aggregate.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.aggregateWithSeries = exports.aggregateWithMeasures = exports.aggregate = exports.AggregatorMap = void 0;
+var tslib_1 = require("tslib");
+var lodash_1 = require("lodash");
+var sum = function (data, measure) {
+    return (0, lodash_1.sumBy)(data, measure);
+};
+var count = function (data, measure) {
+    return data.filter(function (item) { return measure in item; }).length;
+};
+var countDistinct = function (data, measure) {
+    return (0, lodash_1.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 = (0, lodash_1.maxBy)(data, measure)) === null || _a === void 0 ? void 0 : _a[measure];
+};
+var min = function (data, measure) {
+    var _a;
+    return (_a = (0, lodash_1.minBy)(data, measure)) === null || _a === void 0 ? void 0 : _a[measure];
+};
+var mean = function (data, measure) {
+    return (0, lodash_1.meanBy)(data, measure);
+};
+exports.AggregatorMap = {
+    SUM: sum,
+    COUNT: count,
+    MAX: max,
+    MIN: min,
+    MEAN: mean,
+    COUNT_DISTINCT: countDistinct,
+};
+function aggregate(data, groupByField, measures, sort) {
+    var grouped = (0, lodash_1.groupBy)(data, groupByField);
+    var entries = sort ? (0, lodash_1.sortBy)(Object.entries(grouped), '0') : Object.entries(grouped);
+    return entries.map(function (_a) {
+        var _b;
+        var _c = tslib_1.__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 = exports.AggregatorMap[method];
+            datum[measureField] = aggregator(dataGroup, measureField);
+        });
+        return datum;
+    });
+}
+exports.aggregate = aggregate;
+function aggregateWithMeasures(data, groupByField, measures) {
+    var grouped = (0, lodash_1.groupBy)(data, groupByField);
+    var result = [];
+    Object.entries(grouped).forEach(function (_a) {
+        var _b = tslib_1.__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 = exports.AggregatorMap[method];
+                var measureValue = aggregator(dataGroup, measureField);
+                result.push((_a = {},
+                    _a[groupByField] = value,
+                    _a.value = measureValue,
+                    _a.measureName = measureField,
+                    _a));
+            }
+        });
+    });
+    return result;
+}
+exports.aggregateWithMeasures = aggregateWithMeasures;
+function aggregateWithSeries(data, groupByField, measure, expandingField) {
+    var grouped = (0, lodash_1.groupBy)(data, groupByField);
+    var measureField = measure.fieldName, method = measure.method;
+    var aggregator = exports.AggregatorMap[method];
+    return (0, lodash_1.flatten)(Object.entries(grouped).map(function (_a) {
+        var _b = tslib_1.__read(_a, 2), value = _b[0], dataGroup = _b[1];
+        var childGrouped = (0, lodash_1.groupBy)(dataGroup, expandingField);
+        var part = Object.entries(childGrouped).map(function (_a) {
+            var _b;
+            var _c = tslib_1.__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 tslib_1.__assign(tslib_1.__assign({}, item), (_a = {}, _a[groupByField] = value, _a));
+        });
+    }));
+}
+exports.aggregateWithSeries = aggregateWithSeries;

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

@@ -0,0 +1,3 @@
+export declare function sign(value: number): 0 | 1 | -1;
+export declare function unique(arr: string[] | number[]): [(string | number)[], number[]];
+export declare function rank(arr: (string | number)[]): number[];

package/lib/insight/utils/common.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rank = exports.unique = exports.sign = void 0;
+var lodash_1 = require("lodash");
+// sign
+function sign(value) {
+    if (value > 0)
+        return 1;
+    return value < 0 ? -1 : 0;
+}
+exports.sign = sign;
+// unique
+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];
+}
+exports.unique = unique;
+// rank
+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 = (0, lodash_1.lastIndexOf)(sorted, value) + 1;
+        rank.push(firstRank === lastRank ? firstRank : (firstRank + lastRank) / 2);
+    }
+    return rank;
+}
+exports.rank = rank;

package/lib/ntv/generate/generateTextSpec.d.ts

@@ -0,0 +1,9 @@
+import type { NarrativeTextSpec } from '../schema';
+import type { Variable, Structure, StructureTemp } from './types';
+type GenerateParams = {
+    variable: Variable;
+    structures: Structure[];
+    structureTemps?: StructureTemp[];
+};
+export default function generateTextSpec(params: GenerateParams): NarrativeTextSpec;
+export {};