pptx-angular-viewer 1.1.14 → 1.1.15

package/fesm2022/pptx-angular-viewer.mjs

@@ -3274,6 +3274,271 @@ function resolveCategoryLabels(chartData) {
     return Array.from({ length: longest }, (_, i) => String(i + 1));
 }
 
+/**
+ * Map a (possibly fractional / extrapolated) category index to an X pixel.
+ * `mode === 'bar'` centres on category slots; `'line'` anchors at points.
+ * Mirrors the React `xToPixel`.
+ */
+function xToPixel(xVal, catCount, layout, mode) {
+    if (mode === 'bar') {
+        const slotWidth = layout.plotWidth / Math.max(catCount, 1);
+        return layout.plotLeft + slotWidth * xVal + slotWidth / 2;
+    }
+    const maxIdx = Math.max(catCount - 1, 1);
+    return layout.plotLeft + (xVal / maxIdx) * layout.plotWidth;
+}
+/** Ordinary least-squares linear regression of `yVals` on `xVals`. */
+function computeLinearRegression(xVals, yVals) {
+    const n = xVals.length;
+    if (n < 2) {
+        return { slope: 0, intercept: 0, rSquared: 0 };
+    }
+    let sumX = 0;
+    let sumY = 0;
+    let sumXY = 0;
+    let sumXX = 0;
+    for (let i = 0; i < n; i++) {
+        sumX += xVals[i];
+        sumY += yVals[i];
+        sumXY += xVals[i] * yVals[i];
+        sumXX += xVals[i] * xVals[i];
+    }
+    const denom = n * sumXX - sumX * sumX;
+    if (Math.abs(denom) < 1e-12) {
+        return { slope: 0, intercept: sumY / n, rSquared: 0 };
+    }
+    const slope = (n * sumXY - sumX * sumY) / denom;
+    const intercept = (sumY - slope * sumX) / n;
+    const ssRes = yVals.reduce((s, y, i) => s + (y - (slope * xVals[i] + intercept)) ** 2, 0);
+    const meanY = sumY / n;
+    const ssTot = yVals.reduce((s, y) => s + (y - meanY) ** 2, 0);
+    const rSquared = ssTot > 0 ? 1 - ssRes / ssTot : 0;
+    return { slope, intercept, rSquared };
+}
+/** Fit polynomial coefficients (ascending order) via Gaussian elimination. */
+function fitPolynomial(xVals, yVals, order) {
+    const n = xVals.length;
+    const m = order + 1;
+    const matrix = Array.from({ length: m }, () => Array(m + 1).fill(0));
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < m; j++) {
+            let sum = 0;
+            for (let k = 0; k < n; k++) {
+                sum += xVals[k] ** (i + j);
+            }
+            matrix[i][j] = sum;
+        }
+        let sum = 0;
+        for (let k = 0; k < n; k++) {
+            sum += yVals[k] * xVals[k] ** i;
+        }
+        matrix[i][m] = sum;
+    }
+    for (let i = 0; i < m; i++) {
+        let maxRow = i;
+        for (let k = i + 1; k < m; k++) {
+            if (Math.abs(matrix[k][i]) > Math.abs(matrix[maxRow][i])) {
+                maxRow = k;
+            }
+        }
+        [matrix[i], matrix[maxRow]] = [matrix[maxRow], matrix[i]];
+        const pivot = matrix[i][i];
+        if (Math.abs(pivot) < 1e-12) {
+            continue;
+        }
+        for (let j = i; j <= m; j++) {
+            matrix[i][j] /= pivot;
+        }
+        for (let k = 0; k < m; k++) {
+            if (k === i) {
+                continue;
+            }
+            const factor = matrix[k][i];
+            for (let j = i; j <= m; j++) {
+                matrix[k][j] -= factor * matrix[i][j];
+            }
+        }
+    }
+    return matrix.map((row) => row[m]);
+}
+/** R² of an arbitrary fit function against the data. */
+function computeRSquared(xVals, yVals, evalFn) {
+    const n = xVals.length;
+    const meanY = yVals.reduce((s, y) => s + y, 0) / n;
+    let ssRes = 0;
+    let ssTot = 0;
+    for (let i = 0; i < n; i++) {
+        ssRes += (yVals[i] - evalFn(xVals[i])) ** 2;
+        ssTot += (yVals[i] - meanY) ** 2;
+    }
+    return ssTot > 0 ? 1 - ssRes / ssTot : 0;
+}
+/**
+ * Compute the polyline points (and equation / R²) for one trendline over a
+ * series' values. Returns an empty point list when the type is unsupported or
+ * the data is too sparse to fit. Mirrors the React `computeTrendlinePoints`.
+ */
+function computeTrendlinePoints(trendline, values, catCount, layout, range, mode) {
+    const n = values.length;
+    if (n < 2) {
+        return { points: [], equation: '', rSquared: 0 };
+    }
+    const xVals = values.map((_v, i) => i);
+    const yVals = values;
+    const forward = trendline.forward ?? 0;
+    const backward = trendline.backward ?? 0;
+    const startX = -backward;
+    const endX = n - 1 + forward;
+    const steps = Math.max(Math.ceil((endX - startX) * 4), 20);
+    let evalFn;
+    let equation = '';
+    let rSquared = 0;
+    switch (trendline.trendlineType) {
+        case 'linear': {
+            const reg = computeLinearRegression(xVals, yVals);
+            const intercept = trendline.intercept;
+            const slope = intercept !== undefined
+                ? yVals.reduce((s, y, i) => s + (y - intercept) * xVals[i], 0) /
+                    xVals.reduce((s, x) => s + x * x, 0)
+                : reg.slope;
+            const b = intercept ?? reg.intercept;
+            evalFn = (x) => slope * x + b;
+            equation = `y = ${slope.toFixed(2)}x + ${b.toFixed(2)}`;
+            rSquared = reg.rSquared;
+            break;
+        }
+        case 'exponential': {
+            const logY = yVals.filter((y) => y > 0).map((y) => Math.log(y));
+            const filteredX = xVals.filter((_x, i) => yVals[i] > 0);
+            if (logY.length < 2) {
+                return { points: [], equation: '', rSquared: 0 };
+            }
+            const reg = computeLinearRegression(filteredX, logY);
+            const a = Math.exp(reg.intercept);
+            const b = reg.slope;
+            evalFn = (x) => a * Math.exp(b * x);
+            equation = `y = ${a.toFixed(2)}e^(${b.toFixed(2)}x)`;
+            rSquared = reg.rSquared;
+            break;
+        }
+        case 'logarithmic': {
+            const lnX = xVals.filter((x) => x > 0).map((x) => Math.log(x));
+            const filteredY = yVals.filter((_y, i) => xVals[i] > 0);
+            if (lnX.length < 2) {
+                return { points: [], equation: '', rSquared: 0 };
+            }
+            const reg = computeLinearRegression(lnX, filteredY);
+            evalFn = (x) => (x > 0 ? reg.slope * Math.log(x) + reg.intercept : 0);
+            equation = `y = ${reg.slope.toFixed(2)}ln(x) + ${reg.intercept.toFixed(2)}`;
+            rSquared = reg.rSquared;
+            break;
+        }
+        case 'power': {
+            const logX = xVals.filter((x, i) => x > 0 && yVals[i] > 0).map((x) => Math.log(x));
+            const logY = yVals.filter((y, i) => y > 0 && xVals[i] > 0).map((y) => Math.log(y));
+            if (logX.length < 2) {
+                return { points: [], equation: '', rSquared: 0 };
+            }
+            const reg = computeLinearRegression(logX, logY);
+            const a = Math.exp(reg.intercept);
+            evalFn = (x) => (x > 0 ? a * x ** reg.slope : 0);
+            equation = `y = ${a.toFixed(2)}x^${reg.slope.toFixed(2)}`;
+            rSquared = reg.rSquared;
+            break;
+        }
+        case 'polynomial': {
+            const order = Math.min(trendline.order ?? 2, 6);
+            const coeffs = fitPolynomial(xVals, yVals, order);
+            evalFn = (x) => coeffs.reduce((s, c, i) => s + c * x ** i, 0);
+            equation = coeffs.map((c, i) => `${c.toFixed(2)}x^${i}`).join(' + ');
+            rSquared = computeRSquared(xVals, yVals, evalFn);
+            break;
+        }
+        case 'movingAvg': {
+            const period = trendline.period ?? 2;
+            const maPoints = [];
+            for (let i = period - 1; i < n; i++) {
+                let sum = 0;
+                for (let j = i - period + 1; j <= i; j++) {
+                    sum += yVals[j];
+                }
+                const avgVal = sum / period;
+                const px = xToPixel(i, catCount, layout, mode);
+                const py = valueToYLocal(avgVal, range, layout.plotTop, layout.plotBottom);
+                maPoints.push({ x: px, y: py });
+            }
+            return {
+                points: maPoints,
+                equation: `${period}-period moving average`,
+                rSquared: 0,
+            };
+        }
+        default:
+            return { points: [], equation: '', rSquared: 0 };
+    }
+    const points = [];
+    for (let step = 0; step <= steps; step++) {
+        const xVal = startX + ((endX - startX) * step) / steps;
+        const yVal = evalFn(xVal);
+        if (!Number.isFinite(yVal)) {
+            continue;
+        }
+        const px = xToPixel(xVal, catCount, layout, mode);
+        const py = valueToYLocal(yVal, range, layout.plotTop, layout.plotBottom);
+        points.push({ x: px, y: py });
+    }
+    return { points, equation, rSquared };
+}
+/**
+ * Map a value to a Y pixel. Kept local (rather than importing `valueToY`) so
+ * the trendline maths is independent of any future change to the linear
+ * mapping used by the axis renderer — they happen to coincide today.
+ */
+function valueToYLocal(val, range, topY, bottomY) {
+    const usable = bottomY - topY;
+    return bottomY - ((val - range.min) / range.span) * usable;
+}
+/**
+ * Build the renderable trendlines for every series in a chart. Returns an
+ * empty array when no series declares any trendline (so a binding can skip
+ * the overlay entirely).
+ *
+ * @param mode 'bar' for bar/column/stacked plots, 'line' for line/area plots.
+ */
+function computeChartTrendlines(chartData, layout, range, mode, styleId, colorPalette) {
+    const catCount = Math.max(chartData.categories.length, 1);
+    const out = [];
+    chartData.series.forEach((series, si) => {
+        if (!series.trendlines || series.trendlines.length === 0) {
+            return;
+        }
+        series.trendlines.forEach((tl) => {
+            const { points, equation, rSquared } = computeTrendlinePoints(tl, series.values, catCount, layout, range, mode);
+            if (points.length < 2) {
+                return;
+            }
+            const pathData = points.map((p, i) => `${i === 0 ? 'M' : 'L'} ${p.x} ${p.y}`).join(' ');
+            const color = tl.color || seriesColor$1(series, si, styleId, colorPalette);
+            const labelParts = [];
+            if (tl.displayEq && equation) {
+                labelParts.push(equation);
+            }
+            if (tl.displayRSq) {
+                labelParts.push(`R² = ${rSquared.toFixed(4)}`);
+            }
+            const last = points[points.length - 1];
+            out.push({
+                pathData,
+                color,
+                label: labelParts.length > 0 ? labelParts.join('  ') : undefined,
+                labelX: labelParts.length > 0 ? last.x : undefined,
+                labelY: labelParts.length > 0 ? last.y - 6 : undefined,
+            });
+        });
+    });
+    return out;
+}
+
 /**
  * `animation-css` — pure mapping from a core animation preset to CSS.
  *
@@ -5232,7 +5497,8 @@ function snapAngle(angleDeg, step = 15, tolerance = step / 2) {
  * - fills:      `fill-style` (image/gradient/pattern/solid → CSS).
  * - effects:    `visual-effects` (shadow/glow/reflection/DAG), `image-effects`.
  * - text:       `text-warp` (WordArt paths), `omml-to-mathml` (equations).
- * - charts:     `chart-helpers` (layout/palette/axis math).
+ * - charts:     `chart-helpers` (layout/palette/axis math), `chart-trendlines`
+ *               (regression overlays).
  * - animation:  `animation-css` (preset → CSS keyframes).
  * - 3d:         `visual-3d` (scene3d/shape3d → CSS transform/shadow pieces).
  * - tables:     `table-style` (cell style + banding → CSS).