@formant/ava 3.4.1-formant

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

@@ -0,0 +1,9 @@
+import type { InsightType, InsightInfo, Language, HomogeneousInsightType, HomogeneousPatternInfo } from '../../types';
+import type { ParagraphSpec, Structure, StructureTemp } from '../../../ntv/types';
+export type HomogeneousInsightInfo = HomogeneousPatternInfo & Omit<InsightInfo, 'patterns'>;
+export declare abstract class InsightNarrativeStrategy<P = any> {
+    static insightType: InsightType | HomogeneousInsightType;
+    protected static structures: Record<Language, Structure[]>;
+    protected static structureTemps?: Record<Language, StructureTemp[]>;
+    abstract generateTextSpec(insightInfo: InsightInfo<P> | HomogeneousInsightInfo, lang: Language): ParagraphSpec[];
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InsightNarrativeStrategy = void 0;
+var InsightNarrativeStrategy = /** @class */ (function () {
+    function InsightNarrativeStrategy() {
+    }
+    return InsightNarrativeStrategy;
+}());
+exports.InsightNarrativeStrategy = InsightNarrativeStrategy;

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

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

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

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var helpers_1 = require("./helpers");
+var variableMetaMap = {
+    measure: {
+        varType: 'metric_name',
+    },
+    total: {
+        varType: 'metric_value',
+    },
+    '.x': {
+        varType: 'dim_value',
+    },
+};
+var CategoryOutlierNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__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 = (0, ntv_1.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: (0, helpers_1.getDefaultSeparator)('zh-CN'),
+                variableMetaMap: variableMetaMap,
+                useVariable: 'patterns',
+            },
+        ],
+        'en-US': [
+            {
+                templateId: 'outliers',
+                template: '${.x}',
+                separator: (0, helpers_1.getDefaultSeparator)('en-US'),
+                variableMetaMap: variableMetaMap,
+                useVariable: 'patterns',
+            },
+        ],
+    };
+    return CategoryOutlierNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = CategoryOutlierNarrativeStrategy;

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

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

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

@@ -0,0 +1,54 @@
+"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 variableMetaMap = {
+    dateRange: {
+        varType: 'time_desc',
+    },
+    total: {
+        varType: 'metric_value',
+    },
+    measure: {
+        varType: 'metric_name',
+    },
+};
+var ChangePointNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(ChangePointNarrativeStrategy, _super);
+    function ChangePointNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ChangePointNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns, data = insightInfo.data;
+        var dimension = patterns[0].dimension;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: ChangePointNarrativeStrategy.structures[lang],
+            variable: {
+                dateRange: "".concat((0, lodash_1.first)(data)[dimension], "~").concat((0, lodash_1.last)(data)[dimension]),
+                measure: patterns[0].measure,
+                total: patterns.length,
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    ChangePointNarrativeStrategy.insightType = 'change_point';
+    ChangePointNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '${measure} 在 ${dateRange} 中，共出现 ${total} 次较大变化，值得关注。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'In ${dateRange}, ${measure} has ${total} major changes, which is worthy of attention.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return ChangePointNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = ChangePointNarrativeStrategy;

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

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

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var helpers_1 = require("./helpers");
+var variableMetaMap = {
+    measures: {
+        varType: 'metric_name',
+    },
+};
+var CommonnessNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(CommonnessNarrativeStrategy, _super);
+    function CommonnessNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CommonnessNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var measures = insightInfo.measures, dimensions = insightInfo.dimensions, insightType = insightInfo.insightType;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: CommonnessNarrativeStrategy.structures[lang],
+            variable: {
+                measures: measures.map(function (m) { return m.fieldName; }).join((0, helpers_1.getDefaultSeparator)(lang)),
+                dimensions: dimensions.map(function (m) { return m.fieldName; }).join((0, helpers_1.getDefaultSeparator)(lang)),
+                insightType: (0, helpers_1.getInsightName)(insightType, lang),
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    CommonnessNarrativeStrategy.insightType = 'commonness';
+    CommonnessNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '大部分 ${dimensions} 的维值在 ${measures} 上具有 ${insightType}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'Most of the dimension values of ${dimensions} have ${insightType} on ${measures}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return CommonnessNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = CommonnessNarrativeStrategy;

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

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

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var variableMetaMap = {
+    pcorr: {
+        varType: 'metric_value',
+    },
+    m1: {
+        varType: 'metric_value',
+    },
+    m2: {
+        varType: 'metric_value',
+    },
+};
+var CorrelationNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(CorrelationNarrativeStrategy, _super);
+    function CorrelationNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    CorrelationNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns;
+        var _a = patterns[0], _b = tslib_1.__read(_a.measures, 2), m1 = _b[0], m2 = _b[1], pcorr = _a.pcorr;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: CorrelationNarrativeStrategy.structures[lang],
+            variable: {
+                m1: m1,
+                m2: m2,
+                pcorr: pcorr,
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    CorrelationNarrativeStrategy.insightType = 'correlation';
+    CorrelationNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '${m1} 与 ${m2} 相关性最大，相关系数为 ${pcorr}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: '${m1} is most correlated with ${m2} with a correlation coefficient of ${pcorr}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return CorrelationNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = CorrelationNarrativeStrategy;

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

@@ -0,0 +1,10 @@
+import { InsightNarrativeStrategy } from './base';
+import type { HomogeneousInsightInfo } from './base';
+import type { Language, HomogeneousPatternInfo, HomogeneousInsightType } from '../../types';
+import type { ParagraphSpec, Structure, StructureTemp } from '../../../ntv/types';
+export default class ExceptionNarrativeStrategy extends InsightNarrativeStrategy<HomogeneousPatternInfo> {
+    static readonly insightType: HomogeneousInsightType;
+    protected static structures: Record<Language, Structure[]>;
+    protected static structureTemps: Record<Language, StructureTemp[]>;
+    generateTextSpec(insightInfo: HomogeneousInsightInfo, lang: Language): ParagraphSpec[];
+}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var helpers_1 = require("./helpers");
+var variableMetaMap = {
+    measures: {
+        varType: 'metric_name',
+    },
+    '.dim': {
+        varType: 'dim_value',
+    },
+};
+var ExceptionNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(ExceptionNarrativeStrategy, _super);
+    function ExceptionNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    ExceptionNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var measures = insightInfo.measures, dimensions = insightInfo.dimensions, insightType = insightInfo.insightType, exceptions = insightInfo.exceptions;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: ExceptionNarrativeStrategy.structures[lang],
+            structureTemps: ExceptionNarrativeStrategy.structureTemps[lang],
+            variable: {
+                measures: measures.map(function (m) { return m.fieldName; }).join((0, helpers_1.getDefaultSeparator)(lang)),
+                dimensions: dimensions.map(function (m) { return m.fieldName; }).join((0, helpers_1.getDefaultSeparator)(lang)),
+                insightType: (0, helpers_1.getInsightName)(insightType, lang),
+                exceptions: exceptions.map(function (dim) { return ({ dim: dim }); }),
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    ExceptionNarrativeStrategy.insightType = 'exception';
+    ExceptionNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '大部分 ${dimensions} 的维值在 ${measures} 上具有 ${insightType}，除了&{exceptionList}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'Most of the dimension values of ${dimensions} have ${insightType} on ${measures}, except for &{exceptionList}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    ExceptionNarrativeStrategy.structureTemps = {
+        'zh-CN': [
+            {
+                templateId: 'exceptionList',
+                template: '${.dim}',
+                useVariable: 'exceptions',
+                separator: (0, helpers_1.getDefaultSeparator)('zh-CN'),
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                templateId: 'exceptionList',
+                template: '${.dim}',
+                useVariable: 'exceptions',
+                separator: (0, helpers_1.getDefaultSeparator)('en-US'),
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return ExceptionNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = ExceptionNarrativeStrategy;

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

@@ -0,0 +1,5 @@
+import type { Language, InsightType } from '../../types';
+export declare const getDiffDesc: (value: number, lang: Language) => "equal" | "more than" | "超过" | "less than" | "少于" | "持平";
+export declare const INSIGHT_TYPE_NAME: Record<InsightType, string>;
+export declare const getInsightName: (insightType: InsightType, lang: Language) => string;
+export declare const getDefaultSeparator: (lang: Language) => "，" | ", ";

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultSeparator = exports.getInsightName = exports.INSIGHT_TYPE_NAME = exports.getDiffDesc = void 0;
+var lodash_1 = require("lodash");
+var getDiffDesc = function (value, lang) {
+    if (value > 0)
+        return lang === 'en-US' ? 'more than' : '超过';
+    if (value < 0)
+        return lang === 'en-US' ? 'less than' : '少于';
+    return lang === 'en-US' ? 'equal' : '持平';
+};
+exports.getDiffDesc = getDiffDesc;
+exports.INSIGHT_TYPE_NAME = {
+    change_point: '突变点',
+    time_series_outlier: '时序异常值',
+    trend: '趋势',
+    majority: '主要因素',
+    low_variance: '分布均匀',
+    category_outlier: '异常值',
+    correlation: '相关性',
+};
+var getInsightName = function (insightType, lang) {
+    if (lang === 'en-US')
+        return (0, lodash_1.lowerCase)(insightType);
+    return exports.INSIGHT_TYPE_NAME[insightType];
+};
+exports.getInsightName = getInsightName;
+var getDefaultSeparator = function (lang) {
+    return lang === 'zh-CN' ? '，' : ', ';
+};
+exports.getDefaultSeparator = getDefaultSeparator;

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

@@ -0,0 +1,9 @@
+export { default as ChangePointNarrativeStrategy } from './changePoint';
+export { default as TimeSeriesOutlierNarrativeStrategy } from './timeSeriesOutlier';
+export { default as TrendNarrativeStrategy } from './trend';
+export { default as MajorityNarrativeStrategy } from './majority';
+export { default as LowVarianceNarrativeStrategy } from './lowVariance';
+export { default as CategoryNarrativeStrategy } from './categoryOutlier';
+export { default as CorrelationNarrativeStrategy } from './correlation';
+export { default as CommonnessNarrativeStrategy } from './commonness';
+export { default as ExceptionNarrativeStrategy } from './exception';

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

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionNarrativeStrategy = exports.CommonnessNarrativeStrategy = exports.CorrelationNarrativeStrategy = exports.CategoryNarrativeStrategy = exports.LowVarianceNarrativeStrategy = exports.MajorityNarrativeStrategy = exports.TrendNarrativeStrategy = exports.TimeSeriesOutlierNarrativeStrategy = exports.ChangePointNarrativeStrategy = void 0;
+// 趋势类 trend
+var changePoint_1 = require("./changePoint");
+Object.defineProperty(exports, "ChangePointNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(changePoint_1).default; } });
+var timeSeriesOutlier_1 = require("./timeSeriesOutlier");
+Object.defineProperty(exports, "TimeSeriesOutlierNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(timeSeriesOutlier_1).default; } });
+var trend_1 = require("./trend");
+Object.defineProperty(exports, "TrendNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(trend_1).default; } });
+// 分布类 distribute
+var majority_1 = require("./majority");
+Object.defineProperty(exports, "MajorityNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(majority_1).default; } });
+var lowVariance_1 = require("./lowVariance");
+Object.defineProperty(exports, "LowVarianceNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(lowVariance_1).default; } });
+var categoryOutlier_1 = require("./categoryOutlier");
+Object.defineProperty(exports, "CategoryNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(categoryOutlier_1).default; } });
+// 多指标 multi metric
+var correlation_1 = require("./correlation");
+Object.defineProperty(exports, "CorrelationNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(correlation_1).default; } });
+// 共性/例外 homogeneous
+var commonness_1 = require("./commonness");
+Object.defineProperty(exports, "CommonnessNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(commonness_1).default; } });
+var exception_1 = require("./exception");
+Object.defineProperty(exports, "ExceptionNarrativeStrategy", { enumerable: true, get: function () { return __importDefault(exception_1).default; } });

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

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

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

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var tslib_1 = require("tslib");
+/* eslint-disable no-template-curly-in-string */
+var ntv_1 = require("../../../ntv");
+var base_1 = require("./base");
+var variableMetaMap = {
+    measure: {
+        varType: 'metric_name',
+    },
+    mean: {
+        varType: 'metric_value',
+    },
+};
+var LowVarianceNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(LowVarianceNarrativeStrategy, _super);
+    function LowVarianceNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    LowVarianceNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns;
+        var _a = patterns[0], dimension = _a.dimension, measure = _a.measure, mean = _a.mean;
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: LowVarianceNarrativeStrategy.structures[lang],
+            variable: {
+                dimension: dimension,
+                measure: measure,
+                mean: mean,
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    LowVarianceNarrativeStrategy.insightType = 'low_variance';
+    LowVarianceNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '按照 ${dimension} 对 ${measure} 进行拆解，指标分布均匀，平均为 ${mean}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'The quantity is disassembled according to ${dimension}, and ${measure} are evenly distributed, with an average of ${mean}.',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return LowVarianceNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = LowVarianceNarrativeStrategy;

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

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

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

@@ -0,0 +1,64 @@
+"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 variableMetaMap = {
+    measure: {
+        varType: 'metric_name',
+    },
+    total: {
+        varType: 'metric_value',
+    },
+    proportion: {
+        varType: 'proportion',
+    },
+    dimValue: {
+        varType: 'dim_value',
+    },
+    y: {
+        varType: 'metric_value',
+    },
+};
+var MajorityNarrativeStrategy = /** @class */ (function (_super) {
+    tslib_1.__extends(MajorityNarrativeStrategy, _super);
+    function MajorityNarrativeStrategy() {
+        return _super !== null && _super.apply(this, arguments) || this;
+    }
+    MajorityNarrativeStrategy.prototype.generateTextSpec = function (insightInfo, lang) {
+        var patterns = insightInfo.patterns, data = insightInfo.data;
+        var _a = patterns[0], dimension = _a.dimension, measure = _a.measure, x = _a.x, y = _a.y;
+        var total = (0, lodash_1.sumBy)(data, measure);
+        var spec = (0, ntv_1.generateTextSpec)({
+            structures: MajorityNarrativeStrategy.structures[lang],
+            variable: {
+                dimension: dimension,
+                measure: measure,
+                dimValue: x,
+                y: y,
+                total: total,
+                proportion: y / total,
+            },
+        });
+        return spec.sections[0].paragraphs;
+    };
+    MajorityNarrativeStrategy.insightType = 'majority';
+    MajorityNarrativeStrategy.structures = {
+        'zh-CN': [
+            {
+                template: '按照 ${dimension} 对 ${measure} 进行拆解，${dimValue} 的 ${measure} 显著高于其他维值，为 ${y}, 占总数（${total}）的 ${proportion}。',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+        'en-US': [
+            {
+                template: 'Breaking down the ${measure} by ${dimension}, the ${measure} for ${dimValue} is significantly higher than the other dimensions, at ${y}, ${proportion} of the total (${total}).',
+                variableMetaMap: variableMetaMap,
+            },
+        ],
+    };
+    return MajorityNarrativeStrategy;
+}(base_1.InsightNarrativeStrategy));
+exports.default = MajorityNarrativeStrategy;

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

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