@geotab/zenith 3.1.1-beta.6 → 3.2.0-beta.0

package/esm/chart/accessibleChart/accessibleChartNarrative.js

@@ -1,3 +1,4 @@
+import { injectString } from "../../utils/localization/translationsDictionary";
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useLanguage } from "../../utils/localization/useLanguage";
 import { useCallback, useContext, useMemo } from "react";
@@ -8,592 +9,679 @@ import { getFormattedLabel } from "../utils/getFormattedLabel";
 import { truncateDecimals } from "../../utils/truncateDecimals";
 import { calculateMinTruncationPrecision } from "../utils/calculateMinTruncationPrecision";
 import { removeTrendDataFromDatasets } from "../utils/removeTrendDataFromDatasets";
+injectString("cs", "Data", "Data");
+injectString("da-DK", "Data", "Data");
+injectString("de", "Data", "Daten");
+injectString("en", "Data", "Data");
+injectString("es", "Data", "Datos");
+injectString("fi-FI", "Data", "Data");
+injectString("fr", "Data", "Donn\xE9es");
+injectString("fr-FR", "Data", "Donn\xE9es");
+injectString("hu-HU", "Data", "Adatok");
+injectString("id", "Data", "Data");
+injectString("it", "Data", "Dati");
+injectString("ja", "Data", "\u30C7\u30FC\u30BF");
+injectString("ko-KR", "Data", "\uB370\uC774\uD130");
+injectString("ms", "Data", "Data");
+injectString("nb-NO", "Data", "Data");
+injectString("nl", "Data", "Gegevens");
+injectString("pl", "Data", "Dane");
+injectString("pt-BR", "Data", "Dados");
+injectString("sk-SK", "Data", "D\xE1ta");
+injectString("sv", "Data", "Data");
+injectString("th", "Data", "\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25");
+injectString("tr", "Data", "Veri");
+injectString("zh-Hans", "Data", "\u6570\u636E");
+injectString("zh-TW", "Data", "\u8CC7\u6599");
+injectString("en", "switched {TRANSITIONS} times between two states: {STATE1} and {STATE2}.", "switched {TRANSITIONS} times between two states: {STATE1} and {STATE2}.");
+injectString("en", "Highest point(s):", "Highest point(s):");
+injectString("en", "Lowest point(s):", "Lowest point(s):");
+injectString("en", "Segment {INDEX} {DIRECTION} from {FROM} at {X0} to {TO} at {X}.", "Segment {INDEX} {DIRECTION} from {FROM} at {X0} to {TO} at {X}.");
+injectString("en", "shows a complex trend with multiple segments:", "shows a complex trend with multiple segments:");
+injectString("cs", "No data available", "Nejsou k\xA0dispozici \u017E\xE1dn\xE1 data");
+injectString("da-DK", "No data available", "Ingen data tilg\xE6ngelige");
+injectString("de", "No data available", "Keine Daten verf\xFCgbar");
+injectString("en", "No data available", "No data available");
+injectString("es", "No data available", "No hay datos disponibles");
+injectString("fi-FI", "No data available", "Tietoja ei saatavilla");
+injectString("fr", "No data available", "Aucune donn\xE9e disponible");
+injectString("fr-FR", "No data available", "Aucune donn\xE9e disponible");
+injectString("hu-HU", "No data available", "Nincsenek rendelkez\xE9sre \xE1ll\xF3 adatok");
+injectString("id", "No data available", "Tidak ada data tersedia");
+injectString("it", "No data available", "Nessun dato disponibile");
+injectString("ja", "No data available", "\u30C7\u30FC\u30BF\u304C\u3042\u308A\u307E\u305B\u3093");
+injectString("ko-KR", "No data available", "\uC0AC\uC6A9 \uAC00\uB2A5\uD55C \uB370\uC774\uD130\uAC00 \uC5C6\uC2B5\uB2C8\uB2E4");
+injectString("ms", "No data available", "Tiada data tersedia");
+injectString("nb-NO", "No data available", "Ingen data tilgjengelig");
+injectString("nl", "No data available", "Geen gegevens beschikbaar");
+injectString("pl", "No data available", "Brak dost\u0119pnych danych");
+injectString("pt-BR", "No data available", "Nenhum dado dispon\xEDvel");
+injectString("sk-SK", "No data available", "Nie s\xFA k dispoz\xEDcii \u017Eiadne \xFAdaje");
+injectString("sv", "No data available", "Det finns inga tillg\xE4ngliga data");
+injectString("th", "No data available", "\u0E44\u0E21\u0E48\u0E21\u0E35\u0E02\u0E49\u0E2D\u0E21\u0E39\u0E25");
+injectString("tr", "No data available", "Mevcut veri yok");
+injectString("zh-Hans", "No data available", "\u65E0\u53EF\u7528\u6570\u636E");
+injectString("zh-TW", "No data available", "\u6C92\u6709\u53EF\u7528\u8CC7\u6599");
+injectString("en", "Only one data point: value is {VALUE}.", "Only one data point: value is {VALUE}.");
+injectString("en", "Average value is:", "Average value is:");
+injectString("en", "shows a relatively flat or stable trend.", "shows a relatively flat or stable trend.");
+injectString("en", "value changes in the range from {MIN} to {MAX}.", "value changes in the range from {MIN} to {MAX}.");
+injectString("en", "from {FROM} at {X0} to {TO} at {X}.", "from {FROM} at {X0} to {TO} at {X}.");
+injectString("en", "Error generating chart narrative for dataset", "Error generating chart narrative for dataset");
 export function collectAllPoints(dataset, dateFormatter, miniChartLabels, options) {
-    if (dataset.data.length === 0) {
-        return [];
-    }
-    // Minichart data processing
-    if (miniChartLabels) {
-        return dataset.data.map((value, index) => ({
-            x: index,
-            y: typeof value === "number" ? value : 0,
-            originX: index === 0 ? miniChartLabels[0] : (index === dataset.data.length - 1 ? miniChartLabels[miniChartLabels.length - 1] : index)
-        }));
-    }
-    // Standard chart data processing
-    const allPoints = [];
-    for (const [index, point] of dataset.data.entries()) {
-        if (typeof point !== "object" || point === null || !("y" in point)) {
-            continue;
-        }
-        let xNumeric;
-        let originX;
-        const rawXValue = point.x;
-        if (rawXValue instanceof Date || (typeof rawXValue === "string" && isDateString(rawXValue))) {
-            xNumeric = new Date(rawXValue).getTime();
-            originX = getFormattedLabel(rawXValue, dateFormatter, options);
-        }
-        else if (typeof rawXValue === "number") {
-            xNumeric = rawXValue;
-            originX = rawXValue;
-        }
-        else {
-            xNumeric = index;
-            originX = rawXValue;
-        }
-        allPoints.push({ x: xNumeric, y: point.y || 0, originX });
-    }
-    return allPoints;
+  if (dataset.data.length === 0) {
+    return [];
+  }
+  // Minichart data processing
+  if (miniChartLabels) {
+    return dataset.data.map((value, index) => ({
+      x: index,
+      y: typeof value === "number" ? value : 0,
+      originX: index === 0 ? miniChartLabels[0] : index === dataset.data.length - 1 ? miniChartLabels[miniChartLabels.length - 1] : index
+    }));
+  }
+  // Standard chart data processing
+  const allPoints = [];
+  for (const [index, point] of dataset.data.entries()) {
+    if (typeof point !== "object" || point === null || !("y" in point)) {
+      continue;
+    }
+    let xNumeric;
+    let originX;
+    const rawXValue = point.x;
+    if (rawXValue instanceof Date || typeof rawXValue === "string" && isDateString(rawXValue)) {
+      xNumeric = new Date(rawXValue).getTime();
+      originX = getFormattedLabel(rawXValue, dateFormatter, options);
+    } else if (typeof rawXValue === "number") {
+      xNumeric = rawXValue;
+      originX = rawXValue;
+    } else {
+      xNumeric = index;
+      originX = rawXValue;
+    }
+    allPoints.push({
+      x: xNumeric,
+      y: point.y || 0,
+      originX
+    });
+  }
+  return allPoints;
 }
 export function simplifyData(data) {
-    // Need at least 3 points to find a peak or valley
-    if (data.length < 3) {
-        return data;
-    }
-    // Calculate Potential Peak/Valley Height and Dominance for Every Point
-    const scoredData = data.map((currentPoint, i) => {
-        if (currentPoint.y === null) {
-            return {
-                point: currentPoint,
-                peakHeight: 0,
-                valleyHeight: 0,
-                peakDominance: 0,
-                valleyDominance: 0
-            };
-        }
-        let peakHeight = 0;
-        let valleyHeight = 0;
-        let peakDominance = 0;
-        let valleyDominance = 0;
-        let localMinForPeak = currentPoint.y;
-        // Scan left
-        for (let j = i - 1; j >= 0; j--) {
-            const point = data[j];
-            if (point.y !== null && point.y < currentPoint.y) {
-                localMinForPeak = Math.min(localMinForPeak, point.y);
-                peakDominance++;
-            }
-            else {
-                break;
-            }
-        }
-        // Scan right
-        for (let j = i + 1; j < data.length; j++) {
-            const point = data[j];
-            if (point.y !== null && point.y < currentPoint.y) {
-                localMinForPeak = Math.min(localMinForPeak, point.y);
-                peakDominance++;
-            }
-            else {
-                break;
-            }
-        }
-        if (peakDominance > 0) {
-            peakHeight = currentPoint.y - localMinForPeak;
-        }
-        // Calculate Valley Height & Dominance
-        let localMaxForValley = currentPoint.y;
-        // Scan left
-        for (let j = i - 1; j >= 0; j--) {
-            const point = data[j];
-            if (point.y !== null && point.y > currentPoint.y) {
-                localMaxForValley = Math.max(localMaxForValley, point.y);
-                valleyDominance++;
-            }
-            else {
-                break;
-            }
-        }
-        // Scan right
-        for (let j = i + 1; j < data.length; j++) {
-            const point = data[j];
-            if (point.y !== null && point.y > currentPoint.y) {
-                localMaxForValley = Math.max(localMaxForValley, point.y);
-                valleyDominance++;
-            }
-            else {
-                break;
-            }
-        }
-        if (valleyDominance > 0) {
-            valleyHeight = localMaxForValley - currentPoint.y;
-        }
-        return { point: currentPoint, peakHeight, valleyHeight, peakDominance, valleyDominance };
-    });
-    // Filter points by trend change and relative height
-    const significantExtremums = [];
-    const strengthThreshold = 0.50;
-    const yValues = data.filter(p => p.y !== null).map(p => p.y);
-    const minY = yValues.reduce((min, current) => Math.min(min, current));
-    const maxY = yValues.reduce((max, current) => Math.max(max, current));
-    const datasetRange = maxY - minY;
-    // Proceed only if there is a range to avoid division by zero
-    if (datasetRange > 0) {
-        for (let i = 1; i < scoredData.length - 1; i++) {
-            const prev = scoredData[i - 1];
-            const current = scoredData[i];
-            const next = scoredData[i + 1];
-            // Check for a peak in the 'peakHeight' values
-            const isPeak = current.peakHeight > prev.peakHeight && current.peakHeight > next.peakHeight;
-            // Check for a peak in the 'valleyHeight' values
-            const isValley = current.valleyHeight > prev.valleyHeight && current.valleyHeight > next.valleyHeight;
-            if (isPeak) {
-                const relHeight = current.peakHeight / datasetRange;
-                if (relHeight >= strengthThreshold && current.peakDominance > 2) {
-                    significantExtremums.push(current.point);
-                }
-            }
-            else if (isValley) {
-                const relHeight = current.valleyHeight / datasetRange;
-                if (relHeight >= strengthThreshold && current.valleyDominance > 2) {
-                    significantExtremums.push(current.point);
-                }
-            }
-        }
-    }
-    const uniquePointsSet = new Set();
-    const finalResult = [];
-    const addPointIfUnique = (point) => {
-        // using a composite key for uniqueness
-        const key = `${point.x.toString()}-${point.y || ""}`;
-        if (!uniquePointsSet.has(key)) {
-            uniquePointsSet.add(key);
-            finalResult.push(point);
-        }
+  // Need at least 3 points to find a peak or valley
+  if (data.length < 3) {
+    return data;
+  }
+  // Calculate Potential Peak/Valley Height and Dominance for Every Point
+  const scoredData = data.map((currentPoint, i) => {
+    if (currentPoint.y === null) {
+      return {
+        point: currentPoint,
+        peakHeight: 0,
+        valleyHeight: 0,
+        peakDominance: 0,
+        valleyDominance: 0
+      };
+    }
+    let peakHeight = 0;
+    let valleyHeight = 0;
+    let peakDominance = 0;
+    let valleyDominance = 0;
+    let localMinForPeak = currentPoint.y;
+    // Scan left
+    for (let j = i - 1; j >= 0; j--) {
+      const point = data[j];
+      if (point.y !== null && point.y < currentPoint.y) {
+        localMinForPeak = Math.min(localMinForPeak, point.y);
+        peakDominance++;
+      } else {
+        break;
+      }
+    }
+    // Scan right
+    for (let j = i + 1; j < data.length; j++) {
+      const point = data[j];
+      if (point.y !== null && point.y < currentPoint.y) {
+        localMinForPeak = Math.min(localMinForPeak, point.y);
+        peakDominance++;
+      } else {
+        break;
+      }
+    }
+    if (peakDominance > 0) {
+      peakHeight = currentPoint.y - localMinForPeak;
+    }
+    // Calculate Valley Height & Dominance
+    let localMaxForValley = currentPoint.y;
+    // Scan left
+    for (let j = i - 1; j >= 0; j--) {
+      const point = data[j];
+      if (point.y !== null && point.y > currentPoint.y) {
+        localMaxForValley = Math.max(localMaxForValley, point.y);
+        valleyDominance++;
+      } else {
+        break;
+      }
+    }
+    // Scan right
+    for (let j = i + 1; j < data.length; j++) {
+      const point = data[j];
+      if (point.y !== null && point.y > currentPoint.y) {
+        localMaxForValley = Math.max(localMaxForValley, point.y);
+        valleyDominance++;
+      } else {
+        break;
+      }
+    }
+    if (valleyDominance > 0) {
+      valleyHeight = localMaxForValley - currentPoint.y;
+    }
+    return {
+      point: currentPoint,
+      peakHeight,
+      valleyHeight,
+      peakDominance,
+      valleyDominance
     };
-    // Add key points to the array
-    addPointIfUnique(data[0]);
-    addPointIfUnique(data[data.length - 1]);
-    const globalMinPoint = data.find(p => p.y === minY);
-    if (globalMinPoint) {
-        addPointIfUnique(globalMinPoint);
-    }
-    const globalMaxPoint = data.find(p => p.y === maxY);
-    if (globalMaxPoint) {
-        addPointIfUnique(globalMaxPoint);
-    }
-    // Add other significant extremums
-    significantExtremums.forEach(addPointIfUnique);
-    // Sort the final result array chronologically
-    finalResult.sort((a, b) => new Date(a.x).getTime() - new Date(b.x).getTime());
-    // Filter out non-significant points based on area under the curve
-    const getSquare = (p1, p2) => {
-        const x1 = new Date(p1.x).getTime();
-        const x2 = new Date(p2.x).getTime();
-        const y1 = p1.y;
-        const y2 = p2.y;
-        return (x2 - x1) * (y1 + (y2 - y1) / 2);
-    };
-    const immutablePoints = [data[0], data[data.length - 1], globalMinPoint, globalMaxPoint].filter(Boolean);
-    for (let i = 1; i < finalResult.length - 1; i++) {
-        const current = finalResult[i];
-        // Skip removal if the current point is one of the designated immutable points
-        if (immutablePoints.some(p => p && p.x === current.x && p.y === current.y)) {
-            continue;
+  });
+  // Filter points by trend change and relative height
+  const significantExtremums = [];
+  const strengthThreshold = 0.50;
+  const yValues = data.filter(p => p.y !== null).map(p => p.y);
+  const minY = yValues.reduce((min, current) => Math.min(min, current));
+  const maxY = yValues.reduce((max, current) => Math.max(max, current));
+  const datasetRange = maxY - minY;
+  // Proceed only if there is a range to avoid division by zero
+  if (datasetRange > 0) {
+    for (let i = 1; i < scoredData.length - 1; i++) {
+      const prev = scoredData[i - 1];
+      const current = scoredData[i];
+      const next = scoredData[i + 1];
+      // Check for a peak in the 'peakHeight' values
+      const isPeak = current.peakHeight > prev.peakHeight && current.peakHeight > next.peakHeight;
+      // Check for a peak in the 'valleyHeight' values
+      const isValley = current.valleyHeight > prev.valleyHeight && current.valleyHeight > next.valleyHeight;
+      if (isPeak) {
+        const relHeight = current.peakHeight / datasetRange;
+        if (relHeight >= strengthThreshold && current.peakDominance > 2) {
+          significantExtremums.push(current.point);
         }
-        const prev = finalResult[i - 1];
-        const next = finalResult[i + 1];
-        const squareWithPoint = getSquare(prev, current) + getSquare(current, next);
-        const squareWithoutPoint = getSquare(prev, next);
-        const squares = [squareWithPoint, squareWithoutPoint].sort((a, b) => a - b);
-        const squareRatio = squares[0] / squares[1];
-        if (squareRatio > 0.9) {
-            // remove insignificant point
-            finalResult.splice(i, 1);
-            i--;
+      } else if (isValley) {
+        const relHeight = current.valleyHeight / datasetRange;
+        if (relHeight >= strengthThreshold && current.valleyDominance > 2) {
+          significantExtremums.push(current.point);
         }
-    }
-    return finalResult;
+      }
+    }
+  }
+  const uniquePointsSet = new Set();
+  const finalResult = [];
+  const addPointIfUnique = point => {
+    // using a composite key for uniqueness
+    const key = `${point.x.toString()}-${point.y || ""}`;
+    if (!uniquePointsSet.has(key)) {
+      uniquePointsSet.add(key);
+      finalResult.push(point);
+    }
+  };
+  // Add key points to the array
+  addPointIfUnique(data[0]);
+  addPointIfUnique(data[data.length - 1]);
+  const globalMinPoint = data.find(p => p.y === minY);
+  if (globalMinPoint) {
+    addPointIfUnique(globalMinPoint);
+  }
+  const globalMaxPoint = data.find(p => p.y === maxY);
+  if (globalMaxPoint) {
+    addPointIfUnique(globalMaxPoint);
+  }
+  // Add other significant extremums
+  significantExtremums.forEach(addPointIfUnique);
+  // Sort the final result array chronologically
+  finalResult.sort((a, b) => new Date(a.x).getTime() - new Date(b.x).getTime());
+  // Filter out non-significant points based on area under the curve
+  const getSquare = (p1, p2) => {
+    const x1 = new Date(p1.x).getTime();
+    const x2 = new Date(p2.x).getTime();
+    const y1 = p1.y;
+    const y2 = p2.y;
+    return (x2 - x1) * (y1 + (y2 - y1) / 2);
+  };
+  const immutablePoints = [data[0], data[data.length - 1], globalMinPoint, globalMaxPoint].filter(Boolean);
+  for (let i = 1; i < finalResult.length - 1; i++) {
+    const current = finalResult[i];
+    // Skip removal if the current point is one of the designated immutable points
+    if (immutablePoints.some(p => p && p.x === current.x && p.y === current.y)) {
+      continue;
+    }
+    const prev = finalResult[i - 1];
+    const next = finalResult[i + 1];
+    const squareWithPoint = getSquare(prev, current) + getSquare(current, next);
+    const squareWithoutPoint = getSquare(prev, next);
+    const squares = [squareWithPoint, squareWithoutPoint].sort((a, b) => a - b);
+    const squareRatio = squares[0] / squares[1];
+    if (squareRatio > 0.9) {
+      // remove insignificant point
+      finalResult.splice(i, 1);
+      i--;
+    }
+  }
+  return finalResult;
 }
 function getTrendDirectionBySlope(slope) {
-    const slopeThreshold = 1e-10;
-    if (slope > slopeThreshold) {
-        return "increases";
-    }
-    if (slope < -slopeThreshold) {
-        return "decreases";
-    }
-    return "flat";
+  const slopeThreshold = 1e-10;
+  if (slope > slopeThreshold) {
+    return "increases";
+  }
+  if (slope < -slopeThreshold) {
+    return "decreases";
+  }
+  return "flat";
 }
 function calculateLinearRegression(points) {
-    if (points.length < 2) {
-        return { slope: NaN, yIntercept: NaN };
-    }
-    const sumX = points.reduce((sum, p) => sum + p.x, 0);
-    const sumY = points.reduce((sum, p) => sum + p.y, 0);
-    const meanX = sumX / points.length;
-    const meanY = sumY / points.length;
-    let numerator = 0;
-    let denominator = 0;
-    for (const p of points) {
-        numerator += (p.x - meanX) * (p.y - meanY);
-        denominator += (p.x - meanX) * (p.x - meanX);
-    }
-    const slope = denominator === 0 ? 0 : numerator / denominator;
-    const yIntercept = meanY - slope * meanX;
-    return { slope, yIntercept };
+  if (points.length < 2) {
+    return {
+      slope: NaN,
+      yIntercept: NaN
+    };
+  }
+  const sumX = points.reduce((sum, p) => sum + p.x, 0);
+  const sumY = points.reduce((sum, p) => sum + p.y, 0);
+  const meanX = sumX / points.length;
+  const meanY = sumY / points.length;
+  let numerator = 0;
+  let denominator = 0;
+  for (const p of points) {
+    numerator += (p.x - meanX) * (p.y - meanY);
+    denominator += (p.x - meanX) * (p.x - meanX);
+  }
+  const slope = denominator === 0 ? 0 : numerator / denominator;
+  const yIntercept = meanY - slope * meanX;
+  return {
+    slope,
+    yIntercept
+  };
 }
 function detectTwoStateChart(dataset, translate, dateFormatter, miniChartLabels, options) {
-    const allPoints = collectAllPoints(dataset, dateFormatter, miniChartLabels, options);
-    if (allPoints.length <= 2) {
-        return false;
-    }
-    const datasetName = dataset.label || translate("Data");
-    const uniqueYValues = new Set();
-    const tolerance = 1e-6;
-    for (const point of allPoints) {
-        uniqueYValues.add(point.y);
-        if (uniqueYValues.size > 2) {
-            return false;
-        }
-    }
-    const isTwoState = uniqueYValues.size === 2;
-    if (!isTwoState) {
-        return false;
-    }
-    // Count state transitions
-    let transitions = 0;
-    for (let i = 1; i < allPoints.length; i++) {
-        const prevValue = allPoints[i - 1].y;
-        const currentValue = allPoints[i].y;
-        if (Math.abs(prevValue - currentValue) > tolerance) {
-            transitions++;
-        }
-    }
-    const [val1, val2] = uniqueYValues;
-    const decimalLength = calculateMinTruncationPrecision([val1, val2]);
-    const summary = `${datasetName} ${translate("switched {TRANSITIONS} times between two states: {STATE1} and {STATE2}.")
-        .replace("{STATE1}", truncateDecimals(val1, decimalLength).toString())
-        .replace("{STATE2}", truncateDecimals(val2, decimalLength).toString())
-        .replace("{TRANSITIONS}", transitions.toString())}`;
-    return summary;
+  const allPoints = collectAllPoints(dataset, dateFormatter, miniChartLabels, options);
+  if (allPoints.length <= 2) {
+    return false;
+  }
+  const datasetName = dataset.label || translate("Data");
+  const uniqueYValues = new Set();
+  const tolerance = 1e-6;
+  for (const point of allPoints) {
+    uniqueYValues.add(point.y);
+    if (uniqueYValues.size > 2) {
+      return false;
+    }
+  }
+  const isTwoState = uniqueYValues.size === 2;
+  if (!isTwoState) {
+    return false;
+  }
+  // Count state transitions
+  let transitions = 0;
+  for (let i = 1; i < allPoints.length; i++) {
+    const prevValue = allPoints[i - 1].y;
+    const currentValue = allPoints[i].y;
+    if (Math.abs(prevValue - currentValue) > tolerance) {
+      transitions++;
+    }
+  }
+  const [val1, val2] = uniqueYValues;
+  const decimalLength = calculateMinTruncationPrecision([val1, val2]);
+  const summary = `${datasetName} ${translate("switched {TRANSITIONS} times between two states: {STATE1} and {STATE2}.").replace("{STATE1}", truncateDecimals(val1, decimalLength).toString()).replace("{STATE2}", truncateDecimals(val2, decimalLength).toString()).replace("{TRANSITIONS}", transitions.toString())}`;
+  return summary;
 }
 // Calculates the Median Absolute Deviation (MAD) for a given array of numbers.
 function calculateMAD(data, scaleFactor = 1.4826) {
-    if (data.length === 0) {
-        return 0;
-    }
-    // Sort the data to find the median
-    const sortedData = [...data].sort((a, b) => a - b);
-    const mid = Math.floor(sortedData.length / 2);
-    let median;
-    if (sortedData.length % 2 === 0) {
-        median = (sortedData[mid - 1] + sortedData[mid]) / 2;
-    }
-    else {
-        median = sortedData[mid];
-    }
-    // Calculate absolute deviations from the median
-    const deviations = sortedData.map(d => Math.abs(d - median));
-    let mad;
-    const madMid = Math.floor(deviations.length / 2);
-    if (deviations.length % 2 === 0) {
-        mad = (deviations[madMid - 1] + deviations[madMid]) / 2;
-    }
-    else {
-        mad = deviations[madMid];
-    }
-    return mad * scaleFactor;
+  if (data.length === 0) {
+    return 0;
+  }
+  // Sort the data to find the median
+  const sortedData = [...data].sort((a, b) => a - b);
+  const mid = Math.floor(sortedData.length / 2);
+  let median;
+  if (sortedData.length % 2 === 0) {
+    median = (sortedData[mid - 1] + sortedData[mid]) / 2;
+  } else {
+    median = sortedData[mid];
+  }
+  // Calculate absolute deviations from the median
+  const deviations = sortedData.map(d => Math.abs(d - median));
+  let mad;
+  const madMid = Math.floor(deviations.length / 2);
+  if (deviations.length % 2 === 0) {
+    mad = (deviations[madMid - 1] + deviations[madMid]) / 2;
+  } else {
+    mad = deviations[madMid];
+  }
+  return mad * scaleFactor;
 }
 function getInliersForSmallSet(allPoints) {
-    // Only proceed if there are enough points to perform exclusion
-    if (allPoints.length < 3) {
-        return allPoints;
-    }
-    const initialLr = calculateLinearRegression(allPoints);
-    const initialResiduals = allPoints.map((point) => ({
-        point,
-        residual: Math.abs(point.y - (initialLr.slope * point.x + initialLr.yIntercept))
-    }));
-    // Sort to put the worst-fitting point (largest residual) first
-    initialResiduals.sort((a, b) => b.residual - a.residual);
-    // Exclude the top residual (the potential outlier) and return the rest as inliers.
-    return initialResiduals.slice(1).map(r => r.point);
+  // Only proceed if there are enough points to perform exclusion
+  if (allPoints.length < 3) {
+    return allPoints;
+  }
+  const initialLr = calculateLinearRegression(allPoints);
+  const initialResiduals = allPoints.map(point => ({
+    point,
+    residual: Math.abs(point.y - (initialLr.slope * point.x + initialLr.yIntercept))
+  }));
+  // Sort to put the worst-fitting point (largest residual) first
+  initialResiduals.sort((a, b) => b.residual - a.residual);
+  // Exclude the top residual (the potential outlier) and return the rest as inliers.
+  return initialResiduals.slice(1).map(r => r.point);
 }
 function getInliersForLargeSet(allPoints, initialLr) {
-    const initialResiduals = allPoints.map(point => {
-        const predictedY = initialLr.slope * point.x + initialLr.yIntercept;
-        return point.y - predictedY;
-    });
-    const madOfInitialResiduals = calculateMAD(initialResiduals);
-    const strictInlierFilter = 1.5;
-    const pointsForRobustLr = [];
-    if (madOfInitialResiduals > 1e-9) {
-        for (let i = 0; i < allPoints.length; i++) {
-            if (Math.abs(initialResiduals[i]) <= strictInlierFilter * madOfInitialResiduals) {
-                pointsForRobustLr.push(allPoints[i]);
-            }
-        }
-    }
-    else {
-        // If no spread, use all points.
-        pointsForRobustLr.push(...allPoints);
-    }
-    return pointsForRobustLr;
+  const initialResiduals = allPoints.map(point => {
+    const predictedY = initialLr.slope * point.x + initialLr.yIntercept;
+    return point.y - predictedY;
+  });
+  const madOfInitialResiduals = calculateMAD(initialResiduals);
+  const strictInlierFilter = 1.5;
+  const pointsForRobustLr = [];
+  if (madOfInitialResiduals > 1e-9) {
+    for (let i = 0; i < allPoints.length; i++) {
+      if (Math.abs(initialResiduals[i]) <= strictInlierFilter * madOfInitialResiduals) {
+        pointsForRobustLr.push(allPoints[i]);
+      }
+    }
+  } else {
+    // If no spread, use all points.
+    pointsForRobustLr.push(...allPoints);
+  }
+  return pointsForRobustLr;
 }
 function detectSignificantDeviations(allPoints, translate, decimalLength, deviationThreshold = 2) {
-    if (allPoints.length < 3) {
-        return null;
-    }
-    let pointsForRobustLr = [];
-    let initialLr = null;
-    // If the dataset is tiny (where MAD-based filtering is most fragile)
-    if (allPoints.length <= 5) {
-        pointsForRobustLr = getInliersForSmallSet(allPoints);
-    }
-    else {
-        initialLr = calculateLinearRegression(allPoints);
-        pointsForRobustLr = getInliersForLargeSet(allPoints, initialLr);
-    }
-    let finalSlope;
-    let finalYIntercept;
-    // Use the determined pointsForRobustLr for the final regression
-    if (pointsForRobustLr.length < 2) {
-        console.warn("Not enough points for robust regression, falling back to all points.");
-        if (!initialLr) {
-            initialLr = calculateLinearRegression(allPoints);
-        }
-        finalSlope = initialLr.slope;
-        finalYIntercept = initialLr.yIntercept;
-    }
-    else {
-        const robustLr = calculateLinearRegression(pointsForRobustLr);
-        finalSlope = robustLr.slope;
-        finalYIntercept = robustLr.yIntercept;
-    }
-    // Calculate Final Residuals for ALL Original Points against the Robust Line
-    const pointsWithFinalResiduals = allPoints.map(point => {
-        const predictedYRobust = finalSlope * point.x + finalYIntercept;
-        const residual = point.y - predictedYRobust;
-        return Object.assign(Object.assign({}, point), { residual: residual, isSignificantlyHigh: false, isSignificantlyLow: false });
+  if (allPoints.length < 3) {
+    return null;
+  }
+  let pointsForRobustLr = [];
+  let initialLr = null;
+  // If the dataset is tiny (where MAD-based filtering is most fragile)
+  if (allPoints.length <= 5) {
+    pointsForRobustLr = getInliersForSmallSet(allPoints);
+  } else {
+    initialLr = calculateLinearRegression(allPoints);
+    pointsForRobustLr = getInliersForLargeSet(allPoints, initialLr);
+  }
+  let finalSlope;
+  let finalYIntercept;
+  // Use the determined pointsForRobustLr for the final regression
+  if (pointsForRobustLr.length < 2) {
+    console.warn("Not enough points for robust regression, falling back to all points.");
+    if (!initialLr) {
+      initialLr = calculateLinearRegression(allPoints);
+    }
+    finalSlope = initialLr.slope;
+    finalYIntercept = initialLr.yIntercept;
+  } else {
+    const robustLr = calculateLinearRegression(pointsForRobustLr);
+    finalSlope = robustLr.slope;
+    finalYIntercept = robustLr.yIntercept;
+  }
+  // Calculate Final Residuals for ALL Original Points against the Robust Line
+  const pointsWithFinalResiduals = allPoints.map(point => {
+    const predictedYRobust = finalSlope * point.x + finalYIntercept;
+    const residual = point.y - predictedYRobust;
+    return Object.assign(Object.assign({}, point), {
+      residual: residual,
+      isSignificantlyHigh: false,
+      isSignificantlyLow: false
     });
-    const finalResidualsForDetection = pointsWithFinalResiduals.map(p => p.residual);
-    const robustResidualSpread = calculateMAD(finalResidualsForDetection);
-    const SMALL_TOLERANCE = 1e-9;
-    let effectiveDeviationMeasure = robustResidualSpread;
-    const isSmallSet = allPoints.length <= 5;
-    // Calculate the Y-range of the final data set for absolute thresholding
-    const yValues = allPoints.map(p => p.y);
-    const yMin = yValues.reduce((min, current) => Math.min(min, current), Infinity);
-    const yMax = yValues.reduce((max, current) => Math.max(max, current), -Infinity);
-    const yRange = yMax - yMin;
-    // Set a very low absolute residual floor (e.g., 5% of the total range)
-    const ABS_RESIDUAL_FLOOR = yRange * 0.05; // 5% of range
-    if (effectiveDeviationMeasure < SMALL_TOLERANCE) {
-        const maxResidual = finalResidualsForDetection.reduce((max, current) => Math.max(max, Math.abs(current)), 0);
-        effectiveDeviationMeasure = maxResidual > SMALL_TOLERANCE ? maxResidual / (deviationThreshold + SMALL_TOLERANCE) : 0;
-    }
-    else if (isSmallSet) {
-        // Aggressively reduce the spread measure for small sets with non-zero MAD
-        effectiveDeviationMeasure = effectiveDeviationMeasure / 1.5;
-    }
-    const significantDeviations = [];
-    // Detect Significant Deviations using the robust spread
-    if (effectiveDeviationMeasure > SMALL_TOLERANCE) {
-        for (const pointWithRes of pointsWithFinalResiduals) {
-            const isSignificantByMAD = Math.abs(pointWithRes.residual) > deviationThreshold * effectiveDeviationMeasure;
-            const isSignificantByFloor = Math.abs(pointWithRes.residual) > ABS_RESIDUAL_FLOOR;
-            if (isSignificantByMAD || isSignificantByFloor) {
-                significantDeviations.push(Object.assign(Object.assign({}, pointWithRes), { isSignificantlyHigh: pointWithRes.residual > 0, isSignificantlyLow: pointWithRes.residual < 0 }));
-            }
-        }
-    }
-    // Check for Absolute Maximum Inclusion
-    const maxIsIncluded = significantDeviations.some(sd => sd.y === yMax);
-    if (!maxIsIncluded) {
-        const maxPoint = allPoints.find(p => p.y === yMax);
-        if (maxPoint) {
-            // Flag the absolute max as a significant deviation if it was missed
-            significantDeviations.push(Object.assign(Object.assign({}, maxPoint), { residual: maxPoint.y - (finalSlope * maxPoint.x + finalYIntercept), isSignificantlyHigh: true, isSignificantlyLow: false }));
-        }
-    }
-    // Check for Absolute Minimum Inclusion
-    const minIsIncluded = significantDeviations.some(sd => sd.y === yMin);
-    if (!minIsIncluded) {
-        const minPoint = allPoints.find(p => p.y === yMin);
-        if (minPoint) {
-            // Flag the absolute min as a significant deviation if it was missed
-            significantDeviations.push(Object.assign(Object.assign({}, minPoint), { residual: minPoint.y - (finalSlope * minPoint.x + finalYIntercept), isSignificantlyHigh: false, isSignificantlyLow: true // It's the lowest point
-             }));
-        }
-    }
-    if (significantDeviations.length === 0) {
-        return null;
-    }
-    let summary = "";
-    const highestPoints = significantDeviations.filter(sd => sd.isSignificantlyHigh);
-    const lowestPoints = significantDeviations.filter(sd => sd.isSignificantlyLow);
-    const MAX_POINTS_TO_REPORT = 5;
-    if (highestPoints.length > 0) {
-        const uniqueHighestY = [...new Set(highestPoints.map(hp => hp.y))];
-        uniqueHighestY.sort((a, b) => b - a);
-        const limitedHighestY = uniqueHighestY.slice(0, MAX_POINTS_TO_REPORT);
-        const formattedHighestY = limitedHighestY.map(y => truncateDecimals(y, decimalLength)).join(", ");
-        summary += `${translate("Highest point(s):")} ${formattedHighestY}. `;
-    }
-    if (lowestPoints.length > 0) {
-        const uniqueLowestY = [...new Set(lowestPoints.map(lp => lp.y))];
-        uniqueLowestY.sort((a, b) => a - b);
-        const limitedLowestY = uniqueLowestY.slice(0, MAX_POINTS_TO_REPORT);
-        const formattedLowestY = limitedLowestY.map(y => truncateDecimals(y, decimalLength)).join(", ");
-        summary += `${translate("Lowest point(s):")} ${formattedLowestY}. `;
-    }
-    return summary.trim();
+  });
+  const finalResidualsForDetection = pointsWithFinalResiduals.map(p => p.residual);
+  const robustResidualSpread = calculateMAD(finalResidualsForDetection);
+  const SMALL_TOLERANCE = 1e-9;
+  let effectiveDeviationMeasure = robustResidualSpread;
+  const isSmallSet = allPoints.length <= 5;
+  // Calculate the Y-range of the final data set for absolute thresholding
+  const yValues = allPoints.map(p => p.y);
+  const yMin = yValues.reduce((min, current) => Math.min(min, current), Infinity);
+  const yMax = yValues.reduce((max, current) => Math.max(max, current), -Infinity);
+  const yRange = yMax - yMin;
+  // Set a very low absolute residual floor (e.g., 5% of the total range)
+  const ABS_RESIDUAL_FLOOR = yRange * 0.05; // 5% of range
+  if (effectiveDeviationMeasure < SMALL_TOLERANCE) {
+    const maxResidual = finalResidualsForDetection.reduce((max, current) => Math.max(max, Math.abs(current)), 0);
+    effectiveDeviationMeasure = maxResidual > SMALL_TOLERANCE ? maxResidual / (deviationThreshold + SMALL_TOLERANCE) : 0;
+  } else if (isSmallSet) {
+    // Aggressively reduce the spread measure for small sets with non-zero MAD
+    effectiveDeviationMeasure = effectiveDeviationMeasure / 1.5;
+  }
+  const significantDeviations = [];
+  // Detect Significant Deviations using the robust spread
+  if (effectiveDeviationMeasure > SMALL_TOLERANCE) {
+    for (const pointWithRes of pointsWithFinalResiduals) {
+      const isSignificantByMAD = Math.abs(pointWithRes.residual) > deviationThreshold * effectiveDeviationMeasure;
+      const isSignificantByFloor = Math.abs(pointWithRes.residual) > ABS_RESIDUAL_FLOOR;
+      if (isSignificantByMAD || isSignificantByFloor) {
+        significantDeviations.push(Object.assign(Object.assign({}, pointWithRes), {
+          isSignificantlyHigh: pointWithRes.residual > 0,
+          isSignificantlyLow: pointWithRes.residual < 0
+        }));
+      }
+    }
+  }
+  // Check for Absolute Maximum Inclusion
+  const maxIsIncluded = significantDeviations.some(sd => sd.y === yMax);
+  if (!maxIsIncluded) {
+    const maxPoint = allPoints.find(p => p.y === yMax);
+    if (maxPoint) {
+      // Flag the absolute max as a significant deviation if it was missed
+      significantDeviations.push(Object.assign(Object.assign({}, maxPoint), {
+        residual: maxPoint.y - (finalSlope * maxPoint.x + finalYIntercept),
+        isSignificantlyHigh: true,
+        isSignificantlyLow: false
+      }));
+    }
+  }
+  // Check for Absolute Minimum Inclusion
+  const minIsIncluded = significantDeviations.some(sd => sd.y === yMin);
+  if (!minIsIncluded) {
+    const minPoint = allPoints.find(p => p.y === yMin);
+    if (minPoint) {
+      // Flag the absolute min as a significant deviation if it was missed
+      significantDeviations.push(Object.assign(Object.assign({}, minPoint), {
+        residual: minPoint.y - (finalSlope * minPoint.x + finalYIntercept),
+        isSignificantlyHigh: false,
+        isSignificantlyLow: true // It's the lowest point
+      }));
+    }
+  }
+  if (significantDeviations.length === 0) {
+    return null;
+  }
+  let summary = "";
+  const highestPoints = significantDeviations.filter(sd => sd.isSignificantlyHigh);
+  const lowestPoints = significantDeviations.filter(sd => sd.isSignificantlyLow);
+  const MAX_POINTS_TO_REPORT = 5;
+  if (highestPoints.length > 0) {
+    const uniqueHighestY = [...new Set(highestPoints.map(hp => hp.y))];
+    uniqueHighestY.sort((a, b) => b - a);
+    const limitedHighestY = uniqueHighestY.slice(0, MAX_POINTS_TO_REPORT);
+    const formattedHighestY = limitedHighestY.map(y => truncateDecimals(y, decimalLength)).join(", ");
+    summary += `${translate("Highest point(s):")} ${formattedHighestY}. `;
+  }
+  if (lowestPoints.length > 0) {
+    const uniqueLowestY = [...new Set(lowestPoints.map(lp => lp.y))];
+    uniqueLowestY.sort((a, b) => a - b);
+    const limitedLowestY = uniqueLowestY.slice(0, MAX_POINTS_TO_REPORT);
+    const formattedLowestY = limitedLowestY.map(y => truncateDecimals(y, decimalLength)).join(", ");
+    summary += `${translate("Lowest point(s):")} ${formattedLowestY}. `;
+  }
+  return summary.trim();
 }
 function calculateNumberOfSegments(points) {
-    const minPointsForSegmentation = 50;
-    const maxSegments = 8;
-    const base = 5;
-    if (points.length <= minPointsForSegmentation) {
-        return 1;
-    }
-    const calculatedSegments = Math.floor(base * Math.log(points.length));
-    return Math.min(calculatedSegments, maxSegments);
+  const minPointsForSegmentation = 50;
+  const maxSegments = 8;
+  const base = 5;
+  if (points.length <= minPointsForSegmentation) {
+    return 1;
+  }
+  const calculatedSegments = Math.floor(base * Math.log(points.length));
+  return Math.min(calculatedSegments, maxSegments);
 }
 function splitIntoSegments(points) {
-    const numSegments = calculateNumberOfSegments(points);
-    if (numSegments === 1) {
-        return [points];
-    }
-    const segments = [];
-    const segmentSize = Math.floor(points.length / numSegments);
-    const remainder = points.length % numSegments;
-    let startIndex = 0;
-    for (let i = 0; i < numSegments; i++) {
-        const currentSegmentSize = segmentSize + (i < remainder ? 1 : 0);
-        const endIndex = startIndex + currentSegmentSize;
-        segments.push(points.slice(startIndex, endIndex));
-        startIndex = endIndex;
-    }
-    return segments;
+  const numSegments = calculateNumberOfSegments(points);
+  if (numSegments === 1) {
+    return [points];
+  }
+  const segments = [];
+  const segmentSize = Math.floor(points.length / numSegments);
+  const remainder = points.length % numSegments;
+  let startIndex = 0;
+  for (let i = 0; i < numSegments; i++) {
+    const currentSegmentSize = segmentSize + (i < remainder ? 1 : 0);
+    const endIndex = startIndex + currentSegmentSize;
+    segments.push(points.slice(startIndex, endIndex));
+    startIndex = endIndex;
+  }
+  return segments;
 }
 function detectComplexTrend(allPoints, datasetName, decimalLength, translate) {
-    const segments = splitIntoSegments(allPoints);
-    const segmentTrends = segments.map(segment => calculateLinearRegression(segment));
-    const trendDirections = segmentTrends.map(trend => getTrendDirectionBySlope(trend.slope));
-    const isComplex = new Set(trendDirections).size > 1;
-    if (isComplex) {
-        const summaryParts = trendDirections.map((direction, index) => {
-            const startPoint = segments[index][0];
-            const endPoint = segments[index][segments[index].length - 1];
-            return translate(`Segment {INDEX} {DIRECTION} from {FROM} at {X0} to {TO} at {X}.`)
-                .replace("{INDEX}", (index + 1).toString())
-                .replace("{DIRECTION}", direction)
-                .replace("{FROM}", truncateDecimals(startPoint.y, decimalLength).toString())
-                .replace("{TO}", truncateDecimals(endPoint.y, decimalLength).toString())
-                .replace("{X0}", startPoint.originX.toString())
-                .replace("{X}", endPoint.originX.toString());
-        });
-        const complexSummary = `${datasetName} ${translate("shows a complex trend with multiple segments:")} ${summaryParts.join(" ")}`;
-        return complexSummary;
-    }
-    return false;
+  const segments = splitIntoSegments(allPoints);
+  const segmentTrends = segments.map(segment => calculateLinearRegression(segment));
+  const trendDirections = segmentTrends.map(trend => getTrendDirectionBySlope(trend.slope));
+  const isComplex = new Set(trendDirections).size > 1;
+  if (isComplex) {
+    const summaryParts = trendDirections.map((direction, index) => {
+      const startPoint = segments[index][0];
+      const endPoint = segments[index][segments[index].length - 1];
+      return translate("Segment {INDEX} {DIRECTION} from {FROM} at {X0} to {TO} at {X}.").replace("{INDEX}", (index + 1).toString()).replace("{DIRECTION}", direction).replace("{FROM}", truncateDecimals(startPoint.y, decimalLength).toString()).replace("{TO}", truncateDecimals(endPoint.y, decimalLength).toString()).replace("{X0}", startPoint.originX.toString()).replace("{X}", endPoint.originX.toString());
+    });
+    const complexSummary = `${datasetName} ${translate("shows a complex trend with multiple segments:")} ${summaryParts.join(" ")}`;
+    return complexSummary;
+  }
+  return false;
 }
 function calculateAverageValue(points) {
-    const yValues = points.map(point => point.y);
-    const validNumbers = yValues.filter(n => typeof n === "number");
-    if (validNumbers.length === 0) {
-        return null;
-    }
-    const sum = validNumbers.reduce((total, current) => total + current, 0);
-    return sum / validNumbers.length;
+  const yValues = points.map(point => point.y);
+  const validNumbers = yValues.filter(n => typeof n === "number");
+  if (validNumbers.length === 0) {
+    return null;
+  }
+  const sum = validNumbers.reduce((total, current) => total + current, 0);
+  return sum / validNumbers.length;
 }
 function detectDatasetTrend(dataset, translate, dateFormatter, miniChartLabels, options) {
-    const datasetName = dataset.label || translate("Data");
-    const twoState = detectTwoStateChart(dataset, translate, dateFormatter, miniChartLabels, options);
-    if (twoState) {
-        return { trendDirection: "flat", summary: twoState };
-    }
-    const datasetObj = Object.assign({}, dataset);
-    if (!miniChartLabels) {
-        // simplify the data before trend detection
-        datasetObj.data = simplifyData(datasetObj.data);
-    }
-    const allPoints = collectAllPoints(datasetObj, dateFormatter, miniChartLabels, options);
-    if (allPoints.length === 0) {
-        return { trendDirection: "undefined", summary: translate("No data available") };
-    }
-    const allUniqueYValues = [...new Set(allPoints.map(p => p.y))];
-    const decimalLength = calculateMinTruncationPrecision(allUniqueYValues);
-    if (allPoints.length === 1) {
-        return { trendDirection: "flat", summary: translate("Only one data point: value is {VALUE}.").replace("{VALUE}", truncateDecimals(allPoints[0].y, decimalLength).toString()) };
-    }
-    const complexTrend = detectComplexTrend(allPoints, datasetName, decimalLength, translate);
-    if (complexTrend) {
-        return { trendDirection: "complex", summary: complexTrend };
-    }
-    const { slope } = calculateLinearRegression(allPoints);
-    let trendDirection = getTrendDirectionBySlope(slope);
-    const firstPoint = allPoints[0];
-    const lastPoint = allPoints[allPoints.length - 1];
-    const yValues = allPoints.map(p => p.y);
-    const yMin = yValues.reduce((min, current) => Math.min(min, current));
-    const yMax = yValues.reduce((max, current) => Math.max(max, current));
-    const yRange = yMax - yMin;
-    const netChange = lastPoint.y - firstPoint.y;
-    // A tolerance to decide if the net change is significant enough
-    // to overrule a weak linear regression. (e.g., a 5% change of the total range).
-    const NARRATIVE_TREND_THRESHOLD = 0.05;
-    // If the linear regression detected a non-flat trend, check if it's strong enough.
-    if (trendDirection !== "flat" && yRange > 1e-9) {
-        const netChangeRatio = Math.abs(netChange / yRange);
-        if (netChangeRatio < NARRATIVE_TREND_THRESHOLD) {
-            trendDirection = "flat";
-        }
-        else {
-            const netDirection = netChange > 1e-9 ? "increases" : "decreases";
-            if (trendDirection !== netDirection) {
-                trendDirection = netDirection;
-            }
-        }
-    }
-    let summary;
-    if (trendDirection === "flat") {
-        const averageValue = calculateAverageValue(allPoints);
-        const averageString = averageValue ? ` ${translate("Average value is:")} ${truncateDecimals(averageValue, decimalLength)}` : "";
-        const FLAT_TREND_TOLERANCE = 0.25;
-        if (yMax - yMin < FLAT_TREND_TOLERANCE) {
-            summary = `${datasetName} ${translate("shows a relatively flat or stable trend.")} ${averageString}`;
-        }
-        else {
-            const formattedYMin = truncateDecimals(yMin, decimalLength);
-            const formattedYMax = truncateDecimals(yMax, decimalLength);
-            summary = `${datasetName} ${translate("value changes in the range from {MIN} to {MAX}.")
-                .replace("{MIN}", formattedYMin.toString())
-                .replace("{MAX}", formattedYMax.toString())}
+  const datasetName = dataset.label || translate("Data");
+  const twoState = detectTwoStateChart(dataset, translate, dateFormatter, miniChartLabels, options);
+  if (twoState) {
+    return {
+      trendDirection: "flat",
+      summary: twoState
+    };
+  }
+  const datasetObj = Object.assign({}, dataset);
+  if (!miniChartLabels) {
+    // simplify the data before trend detection
+    datasetObj.data = simplifyData(datasetObj.data);
+  }
+  const allPoints = collectAllPoints(datasetObj, dateFormatter, miniChartLabels, options);
+  if (allPoints.length === 0) {
+    return {
+      trendDirection: "undefined",
+      summary: translate("No data available")
+    };
+  }
+  const allUniqueYValues = [...new Set(allPoints.map(p => p.y))];
+  const decimalLength = calculateMinTruncationPrecision(allUniqueYValues);
+  if (allPoints.length === 1) {
+    return {
+      trendDirection: "flat",
+      summary: translate("Only one data point: value is {VALUE}.").replace("{VALUE}", truncateDecimals(allPoints[0].y, decimalLength).toString())
+    };
+  }
+  const complexTrend = detectComplexTrend(allPoints, datasetName, decimalLength, translate);
+  if (complexTrend) {
+    return {
+      trendDirection: "complex",
+      summary: complexTrend
+    };
+  }
+  const {
+    slope
+  } = calculateLinearRegression(allPoints);
+  let trendDirection = getTrendDirectionBySlope(slope);
+  const firstPoint = allPoints[0];
+  const lastPoint = allPoints[allPoints.length - 1];
+  const yValues = allPoints.map(p => p.y);
+  const yMin = yValues.reduce((min, current) => Math.min(min, current));
+  const yMax = yValues.reduce((max, current) => Math.max(max, current));
+  const yRange = yMax - yMin;
+  const netChange = lastPoint.y - firstPoint.y;
+  // A tolerance to decide if the net change is significant enough
+  // to overrule a weak linear regression. (e.g., a 5% change of the total range).
+  const NARRATIVE_TREND_THRESHOLD = 0.05;
+  // If the linear regression detected a non-flat trend, check if it's strong enough.
+  if (trendDirection !== "flat" && yRange > 1e-9) {
+    const netChangeRatio = Math.abs(netChange / yRange);
+    if (netChangeRatio < NARRATIVE_TREND_THRESHOLD) {
+      trendDirection = "flat";
+    } else {
+      const netDirection = netChange > 1e-9 ? "increases" : "decreases";
+      if (trendDirection !== netDirection) {
+        trendDirection = netDirection;
+      }
+    }
+  }
+  let summary;
+  if (trendDirection === "flat") {
+    const averageValue = calculateAverageValue(allPoints);
+    const averageString = averageValue ? ` ${translate("Average value is:")} ${truncateDecimals(averageValue, decimalLength)}` : "";
+    const FLAT_TREND_TOLERANCE = 0.25;
+    if (yMax - yMin < FLAT_TREND_TOLERANCE) {
+      summary = `${datasetName} ${translate("shows a relatively flat or stable trend.")} ${averageString}`;
+    } else {
+      const formattedYMin = truncateDecimals(yMin, decimalLength);
+      const formattedYMax = truncateDecimals(yMax, decimalLength);
+      summary = `${datasetName} ${translate("value changes in the range from {MIN} to {MAX}.").replace("{MIN}", formattedYMin.toString()).replace("{MAX}", formattedYMax.toString())}
                 ${averageString}`;
-        }
-    }
-    else {
-        summary = `${datasetName} ${trendDirection} ${translate("from {FROM} at {X0} to {TO} at {X}.")
-            .replace("{FROM}", truncateDecimals(firstPoint.y, decimalLength).toString())
-            .replace("{TO}", truncateDecimals(lastPoint.y, decimalLength).toString())
-            .replace("{X0}", firstPoint.originX.toString())
-            .replace("{X}", lastPoint.originX.toString())}`;
-        const significantDeviations = detectSignificantDeviations(allPoints, translate, decimalLength);
-        if (significantDeviations && typeof significantDeviations === "string") {
-            summary += ` ${significantDeviations}`;
-        }
     }
-    return { trendDirection, summary };
+  } else {
+    summary = `${datasetName} ${trendDirection} ${translate("from {FROM} at {X0} to {TO} at {X}.").replace("{FROM}", truncateDecimals(firstPoint.y, decimalLength).toString()).replace("{TO}", truncateDecimals(lastPoint.y, decimalLength).toString()).replace("{X0}", firstPoint.originX.toString()).replace("{X}", lastPoint.originX.toString())}`;
+    const significantDeviations = detectSignificantDeviations(allPoints, translate, decimalLength);
+    if (significantDeviations && typeof significantDeviations === "string") {
+      summary += ` ${significantDeviations}`;
+    }
+  }
+  return {
+    trendDirection,
+    summary
+  };
 }
-export const AccessibleChartNarrative = ({ data, options }) => {
-    const { translate } = useLanguage();
-    const miniChartLabels = useMemo(() => data.labels, [data]);
-    const { dateFormat, toLocalDateTime } = useContext(userFormatContext);
-    const dateFormatter = useCallback((d, format = dateFormat) => formatDate(toLocalDateTime(d), format, translate), [toLocalDateTime, dateFormat, translate]);
-    const filteredDatasets = removeTrendDataFromDatasets(data.datasets);
-    const datasetsWithAnalysis = useMemo(() => filteredDatasets.map(dataset => {
-        const datasetObj = Object.assign({}, dataset);
-        try {
-            const trend = detectDatasetTrend(datasetObj, translate, dateFormatter, miniChartLabels, options);
-            return trend.summary;
-        }
-        catch (error) {
-            const errMsg = `${translate("Error generating chart narrative for dataset")} ${dataset.label || ""}`;
-            console.error(errMsg, error);
-            return errMsg;
-        }
-    }), [filteredDatasets, translate, dateFormatter, miniChartLabels, options]);
-    return _jsx("div", { className: "screen-reader-only", children: datasetsWithAnalysis.map((analysis, index) => _jsx("div", { children: analysis }, index)) });
-};
+export const AccessibleChartNarrative = ({
+  data,
+  options
+}) => {
+  const {
+    translate
+  } = useLanguage();
+  const miniChartLabels = useMemo(() => data.labels, [data]);
+  const {
+    dateFormat,
+    toLocalDateTime
+  } = useContext(userFormatContext);
+  const dateFormatter = useCallback((d, format = dateFormat) => formatDate(toLocalDateTime(d), format, translate), [toLocalDateTime, dateFormat, translate]);
+  const filteredDatasets = removeTrendDataFromDatasets(data.datasets);
+  const datasetsWithAnalysis = useMemo(() => filteredDatasets.map(dataset => {
+    const datasetObj = Object.assign({}, dataset);
+    try {
+      const trend = detectDatasetTrend(datasetObj, translate, dateFormatter, miniChartLabels, options);
+      return trend.summary;
+    } catch (error) {
+      const errMsg = `${translate("Error generating chart narrative for dataset")} ${dataset.label || ""}`;
+      console.error(errMsg, error);
+      return errMsg;
+    }
+  }), [filteredDatasets, translate, dateFormatter, miniChartLabels, options]);
+  return _jsx("div", {
+    className: "screen-reader-only",
+    children: datasetsWithAnalysis.map((analysis, index) => _jsx("div", {
+      children: analysis
+    }, index))
+  });
+};