jirametrics 2.25pre7 → 2.25

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 98bcc110a47cd8dfe55eafb58b699d27604f2fb8d24a7ed357e6dd970998af8d
-  data.tar.gz: 2501f1064f33999d31ce42a1dcdf29fd023fb5b60fc06f01294d064d60210fc4
+  metadata.gz: 615528aa77577881d7658b0ce059e9e3972ce4285aeb3c1081c4347dd1a20ca4
+  data.tar.gz: 483cc9b7535da95ca2249813e5ad8ff924334f65c8b7fa84c5705367a9d1b147
 SHA512:
-  metadata.gz: 0761c74f71511217ed38496578d2863df6e5c1fe38d2932fd6fa3c1fed6dd626f5bcbc8bc015ce06aa91d098c55dbff5f1944daba386e39cdb9319f66d658cee
-  data.tar.gz: b3657601410caceb3b186994785609f55d67f80094c945cd34203f68ff8dcdd494ff3d51375498071cfe0f316bf69aef38eac75e3a0e3acfb1462c8b797dc5cd
+  metadata.gz: 36acebeef4d036c6ed043f0073177944c390d5c80ba6ef162319f6a9bbb67bb2762ca4a345f4160d0f1d3fdc7047e257474920c09da9c5770c8a0e45a4748e59
+  data.tar.gz: 2c6f92cdb1d61b49ed7b318bc5c2108649ad387e9af51c312ade43f1522f3cc842dc949dde7d0373d41dc25630bbf9e5a3f883fc9255423ecd6e19c9008b3a4f

data/lib/jirametrics/cfd_data_builder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+class CfdDataBuilder
+  def initialize board:, issues:, date_range:, columns: nil
+    @board = board
+    @issues = issues
+    @date_range = date_range
+    @columns = columns || board.visible_columns
+  end
+
+  def run
+    column_map = build_column_map
+    issue_states = @issues.map { |issue| process_issue(issue, column_map) }
+
+    {
+      columns: @columns.map(&:name),
+      daily_counts: build_daily_counts(issue_states),
+      correction_windows: issue_states.flat_map { |s| s[:correction_windows] }
+    }
+  end
+
+  private
+
+  def build_column_map
+    map = {}
+    @columns.each_with_index do |column, index|
+      column.status_ids.each { |id| map[id] = index }
+    end
+    map
+  end
+
+  # Returns { hwm_timeline: [[date, hwm_value], ...], correction_windows: [...] }
+  def process_issue issue, column_map
+    high_water_mark = nil
+    correction_open_since = nil
+    correction_windows = []
+    hwm_timeline = [] # sorted chronologically by date
+
+    issue.status_changes.each do |change|
+      col_index = column_map[change.value_id]
+      next if col_index.nil?
+
+      if high_water_mark.nil? || col_index > high_water_mark
+        # Forward movement: advance hwm, close any open correction window, record timeline entry
+        if correction_open_since
+          correction_windows << {
+            start_date: correction_open_since,
+            end_date: change.time.to_date,
+            column_index: high_water_mark
+          }
+          correction_open_since = nil
+        end
+        high_water_mark = col_index
+        hwm_timeline << [change.time.to_date, high_water_mark]
+      elsif col_index == high_water_mark && correction_open_since
+        # Same-column recovery: close the correction window without changing hwm or adding timeline entry
+        correction_windows << {
+          start_date: correction_open_since,
+          end_date: change.time.to_date,
+          column_index: high_water_mark
+        }
+        correction_open_since = nil
+      elsif col_index < high_water_mark
+        # Backwards movement: open correction window if not already open
+        correction_open_since ||= change.time.to_date
+      end
+    end
+
+    if correction_open_since
+      correction_windows << {
+        start_date: correction_open_since,
+        end_date: @date_range.end,
+        column_index: high_water_mark
+      }
+    end
+
+    { hwm_timeline: hwm_timeline, correction_windows: correction_windows }
+  end
+
+  def hwm_at hwm_timeline, date
+    result = nil
+    hwm_timeline.each do |timeline_date, hwm|
+      break if timeline_date > date
+
+      result = hwm
+    end
+    result
+  end
+
+  def build_daily_counts issue_states
+    column_count = @columns.size
+    @date_range.each_with_object({}) do |date, result|
+      counts = Array.new(column_count, 0)
+      issue_states.each do |state|
+        hwm = hwm_at(state[:hwm_timeline], date)
+        next if hwm.nil?
+
+        (0..hwm).each { |i| counts[i] += 1 }
+      end
+      result[date] = counts
+    end
+  end
+end

data/lib/jirametrics/cumulative_flow_diagram.rb

@@ -0,0 +1,200 @@
+# frozen_string_literal: true
+
+require 'jirametrics/cfd_data_builder'
+
+class CumulativeFlowDiagram < ChartBase
+  # Used to embed a Chart.js segment callback (which contains JS functions) into
+  # a JSON-like dataset object. The custom to_json emits raw JS rather than a
+  # quoted string, following the same pattern as ExpeditedChart::EXPEDITED_SEGMENT.
+  class Segment
+    def initialize windows
+      # Build a JS array literal of [start_date, end_date] string pairs
+      @windows_js = windows
+        .map { |w| "[#{w[:start_date].to_json}, #{w[:end_date].to_json}]" }
+        .join(', ')
+    end
+
+    def to_json *_args
+      <<~JS
+        {
+          borderDash: function(ctx) {
+            const x = ctx.p1.parsed.x;
+            const windows = [#{@windows_js}];
+            return windows.some(function(w) {
+              return x >= new Date(w[0]).getTime() && x <= new Date(w[1]).getTime();
+            }) ? [6, 4] : undefined;
+          }
+        }
+      JS
+    end
+  end
+  private_constant :Segment
+
+  class CfdColumnRules < Rules
+    attr_accessor :color, :label, :label_hint
+  end
+  private_constant :CfdColumnRules
+
+  def initialize block
+    super()
+    header_text 'Cumulative Flow Diagram'
+    description_text <<~HTML
+      <div class="p">
+        A Cumulative Flow Diagram (CFD) shows how work accumulates across board columns over time.
+        Each coloured band represents a workflow stage. The top edge of the leftmost band shows
+        total work entered; the top edge of the rightmost band shows total work completed.
+      </div>
+      <div class="p">
+        A widening band means work is piling up in that stage — a bottleneck. Parallel top edges
+        (bands staying the same width) indicate smooth flow. Steep rises in the leftmost band
+        without corresponding rises on the right mean new work is arriving faster than it is
+        being finished.
+      </div>
+      <div class="p">
+        Dashed lines and hatched regions indicate periods where an item moved backwards through
+        the workflow (a correction). These highlight rework or process irregularities worth
+        investigating.
+      </div>
+      <div class="p">
+        The chart also overlays two trend lines and an interactive triangle. The <b>arrival rate</b>
+        trend line shows how fast work is entering the system; the <b>departure rate</b> trend line
+        shows how fast it is leaving. Move the mouse over the chart to see a Little's Law triangle
+        at that point in time, labelled with three derived metrics: <b>Work In Progress (WIP)</b> (items started
+        but not finished), <b>approximate average cycle time (CT)</b> (roughly how long an average item takes to complete), and
+        <b>average throughput (TP)</b> (items completed per day). Use the checkbox above the chart to toggle
+        between the triangle and the normal data tooltips.
+      </div>
+    HTML
+    instance_eval(&block)
+  end
+
+  def column_rules &block
+    @column_rules_block = block
+  end
+
+  def triangle_color color
+    @triangle_color = parse_theme_color(color)
+  end
+
+  def arrival_rate_line_color color
+    @arrival_rate_line_color = parse_theme_color(color)
+  end
+
+  def departure_rate_line_color color
+    @departure_rate_line_color = parse_theme_color(color)
+  end
+
+  def run
+    all_columns = current_board.visible_columns
+
+    column_rules_list = all_columns.map do |column|
+      rules = CfdColumnRules.new
+      @column_rules_block&.call(column, rules)
+      rules
+    end
+
+    active_pairs   = all_columns.zip(column_rules_list).reject { |_, rules| rules.ignored? }
+    active_columns = active_pairs.map(&:first)
+    active_rules   = active_pairs.map(&:last)
+
+    cfd = CfdDataBuilder.new(
+      board: current_board,
+      issues: issues,
+      date_range: date_range,
+      columns: active_columns
+    ).run
+
+    columns            = cfd[:columns]
+    daily_counts       = cfd[:daily_counts]
+    correction_windows = cfd[:correction_windows]
+    column_count       = columns.size
+
+    # Convert cumulative totals to marginal band heights for Chart.js stacking.
+    # cumulative[i] = issues that reached column i or further.
+    # marginal[i]   = cumulative[i] - cumulative[i+1]  (last column: marginal = cumulative)
+    daily_marginals = daily_counts.transform_values do |cumulative|
+      cumulative.each_with_index.map do |count, i|
+        i < column_count - 1 ? count - cumulative[i + 1] : count
+      end
+    end
+
+    border_colors = active_rules.map { |rules| rules.color || random_color }
+
+    fill_colors = active_rules.zip(border_colors).map { |rules, border| fill_color_for(rules, border) }
+
+    # Datasets in reversed order: rightmost column first (bottom of stack), leftmost last (top).
+    data_sets = columns.each_with_index.map do |name, col_index|
+      col_windows = correction_windows
+        .select { |w| w[:column_index] == col_index }
+        .map { |w| { start_date: w[:start_date].to_s, end_date: w[:end_date].to_s } }
+
+      {
+        label: active_rules[col_index].label || name,
+        label_hint: active_rules[col_index].label_hint,
+        data: date_range.map { |date| { x: date.to_s, y: daily_marginals[date][col_index] } },
+        backgroundColor: fill_colors[col_index],
+        borderColor: border_colors[col_index],
+        fill: true,
+        tension: 0,
+        segment: Segment.new(col_windows)
+      }
+    end.reverse
+
+    # Correction windows for the afterDraw hatch plugin, with dataset index in
+    # Chart.js dataset array (reversed: done column = index 0).
+    hatch_windows = correction_windows.map do |w|
+      {
+        dataset_index: column_count - 1 - w[:column_index],
+        start_date: w[:start_date].to_s,
+        end_date: w[:end_date].to_s,
+        color: border_colors[w[:column_index]],
+        fill_color: fill_colors[w[:column_index]]
+      }
+    end
+
+    @triangle_color = parse_theme_color(['#333333', '#ffffff']) unless instance_variable_defined?(:@triangle_color)
+    unless instance_variable_defined?(:@arrival_rate_line_color)
+      @arrival_rate_line_color = 'rgba(255,138,101,0.85)'
+    end
+    unless instance_variable_defined?(:@departure_rate_line_color)
+      @departure_rate_line_color = 'rgba(128,203,196,0.85)'
+    end
+
+    wrap_and_render(binding, __FILE__)
+  end
+
+  private
+
+  def parse_theme_color color
+    return color unless color.is_a?(Array)
+
+    raise ArgumentError, 'Color pair must have exactly two elements: [light_color, dark_color]' unless color.size == 2
+    raise ArgumentError, 'Color pair elements must be strings' unless color.all?(String)
+
+    if color.any? { |c| c.start_with?('--') }
+      raise ArgumentError,
+        'CSS variable references are not supported as color pair elements; use a literal color value instead'
+    end
+
+    light, dark = color
+    RawJavascript.new(
+      "(document.documentElement.dataset.theme === 'dark' || " \
+      '(!document.documentElement.dataset.theme && ' \
+      "window.matchMedia('(prefers-color-scheme: dark)').matches)) " \
+      "? #{dark.to_json} : #{light.to_json}"
+    )
+  end
+
+  def hex_to_rgba hex, alpha
+    r, g, b = hex.delete_prefix('#').scan(/../).map { |c| c.to_i(16) }
+    "rgba(#{r}, #{g}, #{b}, #{alpha})"
+  end
+
+  def fill_color_for rules, border
+    if rules.color.nil? || rules.color.match?(/\A#[0-9a-fA-F]{6}\z/)
+      hex_to_rgba(border, 0.35)
+    else
+      rules.color
+    end
+  end
+end

data/lib/jirametrics/examples/standard_project.rb

@@ -58,9 +58,8 @@ class Exporter
             html "<div><a href='#{board.url}'>#{id} #{board.name}</a> (#{board.board_type})</div>",
                  type: :header
           end
-
           daily_view
-
+          cumulative_flow_diagram
           cycletime_scatterplot do
             show_trend_lines
           end
@@ -91,7 +90,6 @@ class Exporter
           flow_efficiency_scatterplot if show_experimental_charts
           sprint_burndown
           estimate_accuracy_chart
-          expedited_chart
           dependency_chart
         end
       end

data/lib/jirametrics/html/cumulative_flow_diagram.erb

@@ -0,0 +1,504 @@
+<%= seam_start %>
+<div class="chart">
+  <label style="font-size:0.85em;display:block;text-align:right;margin-bottom:2px">
+    <input type="checkbox" id="<%= chart_id %>_triangle_toggle" checked>
+    Show flow metrics triangle
+  </label>
+  <canvas id="<%= chart_id %>" width="<%= canvas_width %>" height="<%= canvas_height %>"></canvas>
+</div>
+<script>
+if (!Chart.Tooltip.positioners.legendItem) {
+  Chart.Tooltip.positioners.legendItem = function(items) {
+    return this.chart._legendHoverPosition || Chart.Tooltip.positioners.average.call(this, items);
+  };
+}
+(function() {
+  const hatchWindows = <%= hatch_windows.to_json %>;
+
+  // Custom plugin: draws diagonal hatching over correction windows in the affected band.
+  // Uses createDiagonalPattern() defined in index.js.
+  const cfdHatchPlugin = {
+    id: 'cfdHatch',
+    afterDatasetsDraw: function(chart) {
+      // Redraw each correction-window border line so that the gaps between
+      // dashes show the band fill colour rather than being transparent.
+      // Strategy: draw a solid line in the fill colour first, then the dashed
+      // border line on top. afterDraw (hatching) fires after this, so the
+      // hatch pattern still appears over both lines.
+      const ctx = chart.ctx;
+      const ca  = chart.chartArea;
+      hatchWindows.forEach(function(win) {
+        const meta = chart.getDatasetMeta(win.dataset_index);
+        if (!meta || !meta.data.length) return;
+
+        const startX = chart.scales.x.getPixelForValue(new Date(win.start_date).getTime());
+        const endX   = chart.scales.x.getPixelForValue(new Date(win.end_date).getTime());
+        const lw     = chart.data.datasets[win.dataset_index].borderWidth || 2;
+        const points = meta.data.filter(function(p) { return p.x >= startX - 1 && p.x <= endX + 1; });
+        if (points.length < 2) return;
+
+        function drawSegment(color, dash) {
+          ctx.save();
+          ctx.beginPath();
+          ctx.rect(ca.left, ca.top, ca.width, ca.height);
+          ctx.clip();
+          ctx.strokeStyle = color;
+          ctx.setLineDash(dash);
+          ctx.lineWidth = lw;
+          ctx.beginPath();
+          ctx.moveTo(points[0].x, points[0].y);
+          for (let i = 1; i < points.length; i++) ctx.lineTo(points[i].x, points[i].y);
+          ctx.stroke();
+          ctx.restore();
+        }
+
+        drawSegment(win.fill_color, []);      // solid fill colour fills the gaps
+        drawSegment(win.color,      [6, 4]);  // dashed border colour on top
+      });
+    },
+    afterDraw: function(chart) {
+      const ctx = chart.ctx;
+      const ca  = chart.chartArea;
+      hatchWindows.forEach(function(win) {
+        const meta = chart.getDatasetMeta(win.dataset_index);
+        if (!meta || !meta.data.length) return;
+
+        const startX = chart.scales.x.getPixelForValue(new Date(win.start_date).getTime());
+        const endX   = chart.scales.x.getPixelForValue(new Date(win.end_date).getTime());
+
+        // Draw hatched slices over the correction window.
+        // For stacked line charts, PointElement has no .base — derive the band bottom from the
+        // dataset directly below in the visual stack (dataset_index - 1, since datasets are
+        // stored reversed), or chart.chartArea.bottom for the lowest dataset.
+        // Use a trapezoid clip path per slice so hatching stays within the actual band boundary
+        // even when band height changes between data points.
+        const belowMeta = win.dataset_index > 0 ? chart.getDatasetMeta(win.dataset_index - 1) : null;
+        meta.data.forEach(function(point, i) {
+          if (point.x < startX || point.x > endX) return;
+          const prev       = i > 0 ? meta.data[i - 1] : null;
+          const sliceLeft  = Math.max(prev ? prev.x : startX, startX);
+          const sliceRight = Math.min(point.x, endX);
+          if (sliceLeft >= sliceRight) return;
+
+          const topLeft    = prev ? prev.y : point.y;
+          const topRight   = point.y;
+          const bottomLeft = belowMeta && prev && belowMeta.data[i - 1]
+            ? belowMeta.data[i - 1].y : chart.chartArea.bottom;
+          const bottomRight = belowMeta && belowMeta.data[i]
+            ? belowMeta.data[i].y : chart.chartArea.bottom;
+
+          if (Math.min(topLeft, topRight) >= Math.max(bottomLeft, bottomRight)) return;
+
+          ctx.save();
+          ctx.beginPath();
+          ctx.rect(ca.left, ca.top, ca.width, ca.height);
+          ctx.clip();
+          ctx.beginPath();
+          ctx.moveTo(sliceLeft,  topLeft);
+          ctx.lineTo(sliceRight, topRight);
+          ctx.lineTo(sliceRight, bottomRight);
+          ctx.lineTo(sliceLeft,  bottomLeft);
+          ctx.closePath();
+          ctx.clip();
+          ctx.fillStyle = createDiagonalPattern(win.color);
+          ctx.fillRect(sliceLeft, Math.min(topLeft, topRight),
+            sliceRight - sliceLeft, Math.max(bottomLeft, bottomRight) - Math.min(topLeft, topRight));
+          ctx.restore();
+        });
+      });
+    }
+  };
+
+  const cfdFlowMetricsPlugin = (function () {
+    const triangleColor  = <%= @triangle_color.to_json %>;
+    const arrivalColor   = <%= @arrival_rate_line_color.nil?   ? 'null' : @arrival_rate_line_color.to_json %>;
+    const departureColor = <%= @departure_rate_line_color.nil? ? 'null' : @departure_rate_line_color.to_json %>;
+    function buildArrays(chart) {
+      const ds = chart.data.datasets;
+      const n = ds[0].data.length;
+      const arrivals = [], departures = [];
+      for (let j = 0; j < n; j++) {
+        arrivals[j]   = ds.reduce((s, d) => s + (d.data[j]?.y || 0), 0);
+        // ds[0] is the Done (rightmost) column after dataset reversal.
+        // Its marginal equals its cumulative count (no column to its right),
+        // so this directly gives total departures. Assumes Done is not ignored via column_rules.
+        departures[j] = ds[0].data[j]?.y || 0;
+      }
+      return { arrivals, departures };
+    }
+
+    function linearRegression(yValues) {
+      const n = yValues.length;
+      const sumX  = n * (n - 1) / 2;
+      const sumX2 = n * (n - 1) * (2 * n - 1) / 6;
+      const sumY  = yValues.reduce((s, y) => s + y, 0);
+      const sumXY = yValues.reduce((s, y, i) => s + i * y, 0);
+      const denom = n * sumX2 - sumX * sumX;
+      if (denom === 0) return { slope: 0, intercept: sumY / n };
+      const slope = (n * sumXY - sumX * sumY) / denom;
+      return { slope, intercept: (sumY - slope * sumX) / n };
+    }
+
+    function trendPixelY(chart, reg, dayIndex) {
+      return chart.scales.y.getPixelForValue(reg.slope * dayIndex + reg.intercept);
+    }
+
+    function drawTrendLines(chart, fm) {
+      const ctx = chart.ctx;
+      const ca  = chart.chartArea;
+      const ds  = chart.data.datasets;
+      const n   = ds[0].data.length;
+      const x0  = chart.scales.x.getPixelForValue(new Date(ds[0].data[0].x).getTime());
+      const x1  = chart.scales.x.getPixelForValue(new Date(ds[0].data[n - 1].x).getTime());
+
+      function drawLine(reg, color) {
+        const y0 = trendPixelY(chart, reg, 0);
+        const y1 = trendPixelY(chart, reg, n - 1);
+        ctx.save();
+        ctx.beginPath();
+        ctx.rect(ca.left, ca.top, ca.width, ca.height);
+        ctx.clip();
+        ctx.setLineDash([6, 4]);
+        ctx.lineWidth = 1.5;
+        ctx.strokeStyle = color;
+        ctx.beginPath();
+        ctx.moveTo(x0, y0);
+        ctx.lineTo(x1, y1);
+        ctx.stroke();
+        ctx.restore();
+      }
+
+      if (arrivalColor !== null)   drawLine(fm.arrivalReg,   arrivalColor);
+      if (departureColor !== null) drawLine(fm.departureReg, departureColor);
+
+      // Edge labels (inside chart area, right-aligned to avoid canvas clipping)
+      if (arrivalColor !== null || departureColor !== null) {
+        ctx.save();
+        ctx.font = '10px sans-serif';
+        ctx.textAlign = 'right';
+        ctx.textBaseline = 'middle';
+        const labelX = ca.right - 4;
+        if (arrivalColor !== null) {
+          ctx.fillStyle = arrivalColor;
+          ctx.fillText('Arrivals',   labelX, trendPixelY(chart, fm.arrivalReg,   n - 1));
+        }
+        if (departureColor !== null) {
+          ctx.fillStyle = departureColor;
+          ctx.fillText('Departures', labelX, trendPixelY(chart, fm.departureReg, n - 1));
+        }
+        ctx.restore();
+      }
+    }
+
+    function bgLabel(ctx, text, cx, cy) {
+      ctx.save();
+      ctx.font = '11px sans-serif';
+      const w = ctx.measureText(text).width;
+      ctx.fillStyle = 'rgba(0,0,0,0.55)';
+      ctx.fillRect(cx - w / 2 - 3, cy - 9, w + 6, 14);
+      ctx.fillStyle = '#ffffff';
+      ctx.textAlign = 'center';
+      ctx.textBaseline = 'middle';
+      ctx.fillText(text, cx, cy - 2);
+      ctx.restore();
+    }
+
+    function drawTriangle(ctx, chart, fm) {
+      const ca    = chart.chartArea;
+      const ds    = chart.data.datasets;
+      const n     = ds[0].data.length;
+      const { arrivals, departures, dates } = fm;
+
+      // Locate cursor data index j
+      const cursorMs = chart.scales.x.getValueForPixel(fm.mouseX);
+      const j = dates.reduce((best, t, i) =>
+        Math.abs(t - cursorMs) < Math.abs(dates[best] - cursorMs) ? i : best, 0);
+
+      const wip = arrivals[j] - departures[j];
+      if (wip === 0) return;
+
+      // Find j_c: first index > j where departures[k] >= arrivals[j] (fixed threshold)
+      const threshold = arrivals[j];
+      let j_c = -1;
+      for (let k = j + 1; k < n; k++) {
+        if (departures[k] >= threshold) { j_c = k; break; }
+      }
+
+      const xA = chart.scales.x.getPixelForValue(dates[j]);
+      // Use Chart.js's own rendered pixel positions so the triangle edges
+      // align exactly with the drawn band edges rather than relying on
+      // getPixelForValue(arrivals/departures[j]), which can differ slightly
+      // from the internal stacked totals Chart.js uses when drawing.
+      const yA = chart.getDatasetMeta(ds.length - 1).data[j].y; // top of full stack
+      const yB = chart.getDatasetMeta(0).data[j].y;             // top of done band
+      const xC = j_c >= 0 ? chart.scales.x.getPixelForValue(dates[j_c]) : null;
+
+      ctx.save();
+      ctx.beginPath();
+      ctx.rect(ca.left, ca.top, ca.width, ca.height);
+      ctx.clip();
+
+      // Triangle fill (only when C is within range)
+      if (xC !== null) {
+        ctx.beginPath();
+        ctx.moveTo(xA, yA);
+        ctx.lineTo(xA, yB);
+        ctx.lineTo(xC, yA);
+        ctx.closePath();
+        ctx.fillStyle = 'rgba(255,255,255,0.06)';
+        ctx.fill();
+      }
+
+      // AB: vertical (WIP)
+      ctx.setLineDash([]);
+      ctx.lineWidth = 2;
+      ctx.strokeStyle = triangleColor;
+      ctx.beginPath();
+      ctx.moveTo(xA, yA);
+      ctx.lineTo(xA, yB);
+      ctx.stroke();
+
+      if (xC !== null) {
+        // AC: horizontal (cycle time)
+        ctx.beginPath();
+        ctx.moveTo(xA, yA);
+        ctx.lineTo(xC, yA);
+        ctx.stroke();
+        // BC: dashed hypotenuse (throughput)
+        ctx.setLineDash([4, 2]);
+        ctx.lineWidth = 1.5;
+        ctx.beginPath();
+        ctx.moveTo(xA, yB);
+        ctx.lineTo(xC, yA);
+        ctx.stroke();
+      } else {
+        // C outside range: dashed extension to right edge
+        ctx.setLineDash([4, 2]);
+        ctx.lineWidth = 1.5;
+        ctx.beginPath();
+        ctx.moveTo(xA, yA);
+        ctx.lineTo(ca.right, yA);
+        ctx.stroke();
+      }
+
+      ctx.restore();
+
+      // Labels
+      const abMidY = (yA + yB) / 2;
+      // WIP: right-aligned, left of AB
+      ctx.save();
+      ctx.font = '11px sans-serif';
+      const wipText = 'WIP: ' + wip;
+      const wipW = ctx.measureText(wipText).width;
+      ctx.fillStyle = 'rgba(0,0,0,0.55)';
+      ctx.fillRect(xA - wipW - 8, abMidY - 9, wipW + 6, 14);
+      ctx.fillStyle = '#ffffff';
+      ctx.textAlign = 'right';
+      ctx.textBaseline = 'middle';
+      ctx.fillText(wipText, xA - 5, abMidY - 2);
+      ctx.restore();
+
+      if (xC !== null) {
+        const cycleTime = j_c - j;
+        const throughput = (wip / cycleTime).toFixed(2);
+        bgLabel(ctx, '~CT: ' + cycleTime + ' days', (xA + xC) / 2, yA - 10);
+        bgLabel(ctx, '~TP: ' + throughput + '/day', (xA + xC) / 2, (yA + yB) / 2 + 12);
+      }
+    }
+
+    return {
+      id: 'cfdFlowMetrics',
+
+      afterInit(chart) {
+        const { arrivals, departures } = buildArrays(chart);
+        const dates = chart.data.datasets[0].data.map(d => new Date(d.x).getTime());
+        chart._flowMetrics = {
+          mouseX:      null,
+          arrivals,
+          departures,
+          dates,
+          arrivalReg:  linearRegression(arrivals),
+          departureReg: linearRegression(departures)
+        };
+        const fm = chart._flowMetrics;
+        const canvas = chart.canvas;
+
+        // The triangle is drawn on a separate overlay canvas using native DOM
+        // events, completely bypassing Chart.js's render/event cycle (which
+        // behaves unreliably in Safari). The triangle is hidden immediately on
+        // mouse move and redrawn after a short pause (debounce), preventing the
+        // browser from being overwhelmed by rapid redraws.
+        const dpr     = window.devicePixelRatio || 1;
+        const parent = canvas.parentNode;
+        if (getComputedStyle(parent).position === 'static') parent.style.position = 'relative';
+        // Read canvas.offsetTop/Left after parent is positioned so they are
+        // relative to parent — this accounts for the label/checkbox above the
+        // canvas that would otherwise shift the overlay upward.
+        const overlay = document.createElement('canvas');
+        overlay.width  = canvas.width;
+        overlay.height = canvas.height;
+        overlay.style.cssText = 'position:absolute;top:' + canvas.offsetTop + 'px;' +
+          'left:' + canvas.offsetLeft + 'px;pointer-events:none;' +
+          'width:'  + (canvas.style.width  || (canvas.width  / dpr) + 'px') + ';' +
+          'height:' + (canvas.style.height || (canvas.height / dpr) + 'px') + ';';
+        parent.insertBefore(overlay, canvas.nextSibling);
+
+        const octx  = overlay.getContext('2d');
+        octx.scale(dpr, dpr);
+        const cssW = canvas.width  / dpr;
+        const cssH = canvas.height / dpr;
+        fm._overlay = overlay;
+
+        // Store overlay state on fm so afterDraw can reach it.
+        fm._overlayCtx     = octx;
+        fm._cssW           = cssW;
+        fm._cssH           = cssH;
+        fm._triangleEnabled = true;
+        fm._rafId          = null;
+
+        // Checkbox toggles between triangle mode and tooltip mode. They are
+        // mutually exclusive: in triangle mode, Chart.js event processing is
+        // disabled entirely so its internal hover/tooltip logic cannot interfere
+        // with the overlay canvas rAF (which hangs Safari at certain positions).
+        // Our native canvas mousemove handler is unaffected by this setting.
+        const defaultEvents = ['mousemove', 'mouseout', 'click', 'touchstart', 'touchmove'];
+
+        function setTriangleMode(enabled) {
+          fm._triangleEnabled = enabled;
+          if (enabled) {
+            chart.options.events = [];
+            chart.options.plugins.tooltip.enabled = false;
+          } else {
+            chart.options.events = defaultEvents;
+            chart.options.plugins.tooltip.enabled = true;
+            octx.clearRect(0, 0, cssW, cssH);
+          }
+          chart.update('none');
+        }
+
+        const checkbox = document.getElementById('<%= chart_id %>_triangle_toggle');
+        if (checkbox) {
+          checkbox.addEventListener('change', function () { setTriangleMode(this.checked); });
+        }
+        // Apply initial triangle mode without triggering a redundant update
+        // (tooltip is already disabled in the chart config; just silence events).
+        chart.options.events = [];
+
+        function scheduleOverlayRedraw() {
+          if (fm._rafId !== null) return;
+          fm._rafId = requestAnimationFrame(function () {
+            fm._rafId = null;
+            if (fm._triangleEnabled) {
+              octx.clearRect(0, 0, cssW, cssH);
+              if (fm.mouseX !== null) drawTriangle(octx, chart, fm);
+            }
+          });
+        }
+
+        function onMouseMove(e) {
+          const rect = canvas.getBoundingClientRect();
+          const x = e.clientX - rect.left;
+          const y = e.clientY - rect.top;
+          const ca = chart.chartArea;
+          if (!ca) return;
+          fm.mouseX = (x >= ca.left && x <= ca.right && y >= ca.top && y <= ca.bottom) ? x : null;
+          scheduleOverlayRedraw();
+        }
+
+        function onMouseLeave() {
+          fm.mouseX = null;
+          scheduleOverlayRedraw();
+        }
+
+        canvas.addEventListener('mousemove',  onMouseMove);
+        canvas.addEventListener('mouseleave', onMouseLeave);
+        fm._onMouseMove  = onMouseMove;
+        fm._onMouseLeave = onMouseLeave;
+      },
+
+      destroy(chart) {
+        const fm = chart._flowMetrics;
+        if (!fm) return;
+        chart.canvas.removeEventListener('mousemove',  fm._onMouseMove);
+        chart.canvas.removeEventListener('mouseleave', fm._onMouseLeave);
+        if (fm._overlay && fm._overlay.parentNode) fm._overlay.parentNode.removeChild(fm._overlay);
+      },
+
+      afterDraw(chart) {
+        const fm = chart._flowMetrics;
+        drawTrendLines(chart, fm);
+        // Triangle is on the overlay canvas — no drawing needed here.
+      }
+    };
+  })();
+
+  new Chart(document.getElementById('<%= chart_id %>').getContext('2d'), {
+    type: 'line',
+    plugins: [cfdHatchPlugin, cfdFlowMetricsPlugin],
+    data: {
+      datasets: <%= JSON.generate(data_sets) %>
+    },
+    options: {
+      responsive: <%= canvas_responsive? %>,
+      scales: {
+        x: {
+          type: 'time',
+          time: { format: 'YYYY-MM-DD' },
+          min: "<%= date_range.begin.to_s %>",
+          max: "<%= (date_range.end + 1).to_s %>",
+          grid: { color: <%= CssVariable['--grid-line-color'].to_json %> }
+        },
+        y: {
+          stacked: true,
+          min: 0,
+          title: { display: true, text: 'Number of items' },
+          grid: { color: <%= CssVariable['--grid-line-color'].to_json %> }
+        }
+      },
+      elements: {
+        point: { radius: 0 }
+      },
+      plugins: {
+        tooltip: {
+          enabled: false,
+          position: 'legendItem',
+          callbacks: {
+            title: function(contexts) {
+              if (contexts[0]?.chart._legendHoverIndex != null) return '';
+            },
+            label: function(context) {
+              if (context.chart._legendHoverIndex != null) {
+                return context.dataset.label_hint || '';
+              }
+            }
+          }
+        },
+        legend: {
+          reverse: true,
+          onHover: function(event, legendItem, legend) {
+            const chart = legend.chart;
+            const dataset = chart.data.datasets[legendItem.datasetIndex];
+            if (!dataset?.label_hint) return;
+            chart._legendHoverIndex = legendItem.datasetIndex;
+            chart._legendHoverPosition = { x: event.x, y: event.y };
+            const firstNonZero = dataset.data.findIndex(d => d?.y !== 0);
+            if (firstNonZero === -1) return;
+            chart.tooltip.setActiveElements(
+              [{ datasetIndex: legendItem.datasetIndex, index: firstNonZero }],
+              { x: event.x, y: event.y }
+            );
+            chart.update();
+          },
+          onLeave: function(event, legendItem, legend) {
+            legend.chart._legendHoverIndex = null;
+            legend.chart._legendHoverPosition = null;
+            legend.chart.tooltip.setActiveElements([], { x: 0, y: 0 });
+            legend.chart.update();
+          }
+        }
+      }
+    }
+  });
+})();
+</script>
+<%= seam_end %>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jirametrics
 version: !ruby/object:Gem::Version
-  version: 2.25pre7
+  version: '2.25'
 platform: ruby
 authors:
 - Mike Bowler
@@ -73,10 +73,12 @@ files:
 - lib/jirametrics/board_config.rb
 - lib/jirametrics/board_feature.rb
 - lib/jirametrics/board_movement_calculator.rb
+- lib/jirametrics/cfd_data_builder.rb
 - lib/jirametrics/change_item.rb
 - lib/jirametrics/chart_base.rb
 - lib/jirametrics/columns_config.rb
 - lib/jirametrics/css_variable.rb
+- lib/jirametrics/cumulative_flow_diagram.rb
 - lib/jirametrics/cycle_time_config.rb
 - lib/jirametrics/cycletime_histogram.rb
 - lib/jirametrics/cycletime_scatterplot.rb
@@ -109,6 +111,7 @@ files:
 - lib/jirametrics/html/aging_work_in_progress_chart.erb
 - lib/jirametrics/html/aging_work_table.erb
 - lib/jirametrics/html/collapsible_issues_panel.erb
+- lib/jirametrics/html/cumulative_flow_diagram.erb
 - lib/jirametrics/html/daily_wip_chart.erb
 - lib/jirametrics/html/estimate_accuracy_chart.erb
 - lib/jirametrics/html/expedited_chart.erb