diff --git a/.devbook/domain/roadmap/features.md b/.devbook/domain/roadmap/features.md index 766710f39..f7a4a68fc 100644 --- a/.devbook/domain/roadmap/features.md +++ b/.devbook/domain/roadmap/features.md @@ -320,11 +320,12 @@ related: [.devbook/domain/roadmap/features.md#looking-back-at-finished-plans] ``` The timeline fills the width it is given and is ruled finer the nearer it is to -today: this week a column a day, the next three weeks a column each, then months for -about a quarter, then quarters. The work in flight sits this week, and a single week +today, the same way in both directions: last week, this week and next a column a +day, the three weeks either side of those a column each, then months for about a +quarter, then quarters. The work in flight sits around today, and a single week column stacked every bar that started in it on the same few pixels. Every column -widens by the same factor until the chart from this week on fills the screen, so a -short plan never leaves the right of it empty, and the chart opens on this week. +widens by the same factor until the chart from last week on fills the screen, so a +short plan never leaves the right of it empty, and the chart opens on last week. ### Looking back at finished plans @@ -338,8 +339,9 @@ Scroll back from this week to see what was finished and how long it really took. plan whose tasks are all done is drawn where its work actually ran — from the day its first task was started to the day its last was ticked off — rather than where it was planned, because a finished plan is a record and its planned window was only a -hope. The four weeks before this one are ruled in weeks, where recent work sits, and -anything earlier in months, as far back as the earliest thing drawn. +hope. History is ruled as the horizon is, mirrored: last week in days and the three +weeks before it in weeks, always, where recent work sits; then months for at least a +quarter, then quarters, as far back as the earliest thing drawn. A finished plan cannot be dragged: its dates are read off the work, so a move would change nothing the next reading keeps. Opening it still edits the stored item. diff --git a/src/Core/Backlog.UI.Components/Roadmap/RoadmapTimeline.razor b/src/Core/Backlog.UI.Components/Roadmap/RoadmapTimeline.razor index 15ea5b314..3f66a379f 100644 --- a/src/Core/Backlog.UI.Components/Roadmap/RoadmapTimeline.razor +++ b/src/Core/Backlog.UI.Components/Roadmap/RoadmapTimeline.razor @@ -898,16 +898,17 @@ private RoadmapGeometry Geometry => new(Span, QuarterWidth * Stretch, RowHeight, BarHeight); - /// Where the part of the chart that has to fill the screen begins: this - /// week when it is on the chart, so history to the left is scrolled to rather - /// than squeezed in, and the window's start otherwise. + /// Where the part of the chart that has to fill the screen begins: the + /// week before this one when it is on the chart — so the days either side of + /// today are what it opens on, and older history to the left is scrolled to + /// rather than squeezed in — and the window's start otherwise. private DateOnly FillFrom { get { if (Today is not { } today || !Span.Contains(today)) return Span.Start; - var week = RoadmapWindow.StartOfWeek(today, WeekStart); + var week = RoadmapWindow.StartOfWeek(today, WeekStart).AddDays(Span.IsGraduated ? -7 * RoadmapWindow.GraduatedDayWeeks : 0); return week < Span.Start ? Span.Start : week; } diff --git a/src/Core/Backlog.UI.Components/Roadmap/RoadmapWindow.cs b/src/Core/Backlog.UI.Components/Roadmap/RoadmapWindow.cs index 1d9809829..d65714f35 100644 --- a/src/Core/Backlog.UI.Components/Roadmap/RoadmapWindow.cs +++ b/src/Core/Backlog.UI.Components/Roadmap/RoadmapWindow.cs @@ -104,42 +104,46 @@ public static RoadmapWindow Covering(IEnumerable dates, DateOnly fallb return new RoadmapWindow(StartOfQuarter(first), EndOfQuarter(last)); } - /// How many weeks a graduated window rules finer than a month on either - /// side of today, counting this week — which is itself ruled in days. - public const int GraduatedWeeks = 4; + /// How many weeks either side of today a graduated window rules in days: + /// this week, and this many before and after it. + public const int GraduatedDayWeeks = 1; + + /// How many weeks a graduated window rules a column a week on either + /// side, beyond the weeks it rules in days. + public const int GraduatedWeeks = 3; /// - /// A window ruled coarser the further it reaches from today: a column per day - /// for this week, a column per week for the minus - /// one after it, a column per month for roughly three months after that, and a - /// column per quarter beyond. + /// A window ruled coarser the further it reaches from today, the same way in + /// both directions: a column per day for this week and the + /// either side of it, a column per week for the + /// beyond those, a column per month for roughly a + /// quarter beyond that, and a column per quarter beyond. /// /// The near term is what gets planned in detail and rescheduled by the week, so - /// that is where the ruler is fine enough to read a week off — and this week - /// finer still, because it is where the work in flight sits, and a single week - /// column stacked every bar that started this week on the same few pixels. - /// Next quarter is a month-level commitment, and anything further out is an - /// intention, which a weekly ruler would only make look more certain than it is. + /// that is where the ruler is fine enough to read a week off — and the days + /// around today finer still, because that is where the work in flight sits, and + /// a single week column stacked every bar that started in it on the same few + /// pixels. A day ruler from the start of last week to the end of next means + /// today always has at least a full week of days on both sides. Next quarter is + /// a month-level commitment, and anything further out is an intention, which a + /// weekly ruler would only make look more certain than it is. /// /// - /// The weeks are whole, so they rarely end on a month start: the month they end - /// in is drawn as a column covering only its remaining days, and every month - /// after it is whole. The months run up to a quarter start, so every quarter is - /// whole too. + /// The weeks are whole, so they rarely meet a month boundary: the month nearest + /// them on either side is a column clipped to the days it has left, and every + /// month beyond is whole. The months run to a quarter boundary, so every + /// quarter is whole too. /// /// /// Before this week is history, reached by scrolling back — finished plans are - /// drawn where their work actually happened. It is ruled in weeks for the - /// before this one, where recently finished work - /// sits, and in months before that, the last clipped to meet the first week. - /// The weeks are always there, so a reader can look back at the last month - /// whatever is drawn; the months reach only as far back as the earliest date - /// given. + /// drawn where their work actually happened. Its days and weeks are always + /// there, so a reader can look back at the last month whatever is drawn; its + /// months and quarters reach only as far back as the earliest date given. /// /// - /// It always reaches at least to the end of the monthly tier, so the horizon's - /// shape is visible even for a plan that stops next month, and further when - /// the plan does. + /// After it, the window always reaches at least to the end of the monthly tier, + /// so the horizon's shape is visible even for a plan that stops next month, and + /// further when the plan does. /// /// public static RoadmapWindow Graduated(IEnumerable dates, DateOnly today, DayOfWeek weekStart) @@ -147,10 +151,17 @@ public static RoadmapWindow Graduated(IEnumerable dates, DateOnly toda var days = dates as ICollection ?? [.. dates]; var thisWeek = StartOfWeek(today, weekStart); - var weeksFrom = thisWeek.AddDays(7); - var monthsFrom = thisWeek.AddDays(7 * GraduatedWeeks); + + // Forward: days to weeksFrom, weeks to monthsFrom, months to quartersFrom. + var weeksFrom = thisWeek.AddDays(7 * (GraduatedDayWeeks + 1)); + var monthsFrom = weeksFrom.AddDays(7 * GraduatedWeeks); var quartersFrom = FirstOfQuarterOnOrAfter(monthsFrom.AddMonths(3)); - var pastWeeksFrom = thisWeek.AddDays(-7 * GraduatedWeeks); + + // Backward, the mirror: days from pastDaysFrom, weeks from pastWeeksFrom, + // months from pastMonthsFrom, quarters before that. + var pastDaysFrom = thisWeek.AddDays(-7 * GraduatedDayWeeks); + var pastWeeksFrom = pastDaysFrom.AddDays(-7 * GraduatedWeeks); + var pastMonthsFrom = StartOfQuarter(pastWeeksFrom.AddMonths(-3)); var first = days.Count == 0 ? thisWeek : days.Min(); var last = days.Count == 0 ? quartersFrom.AddDays(-1) : days.Max(); @@ -160,38 +171,53 @@ public static RoadmapWindow Graduated(IEnumerable dates, DateOnly toda var previousYear = 0; var previousMonth = 0; - // Long before this week: months, the last one clipped to meet the first week. - for (var cursor = first < pastWeeksFrom ? new DateOnly(first.Year, first.Month, 1) : pastWeeksFrom; cursor < pastWeeksFrom; cursor = cursor.AddMonths(1)) + // Long before this week: quarters, as far back as the earliest date. + for (var cursor = StartOfQuarter(first); cursor < pastMonthsFrom; cursor = cursor.AddMonths(3)) + { + columns.Add(Quarter(cursor)); + previousYear = cursor.Year; + } + + // Then months, the last one clipped to meet the first week. + var monthsStart = first < pastMonthsFrom ? pastMonthsFrom + : first < pastWeeksFrom ? new DateOnly(first.Year, first.Month, 1) + : pastWeeksFrom; + for (var cursor = monthsStart; cursor < pastWeeksFrom; cursor = cursor.AddMonths(1)) { columns.Add(Month(cursor, Min(cursor.AddMonths(1).AddDays(-1), pastWeeksFrom.AddDays(-1)), previousYear != cursor.Year)); previousYear = cursor.Year; previousMonth = cursor.Month; } - // Just before it: weeks, always all of them, so there is recent history to - // scroll back into even when nothing drawn began before this week. - for (var cursor = pastWeeksFrom; cursor < thisWeek; cursor = cursor.AddDays(7)) + // Just before the days: weeks, always all of them, so there is recent + // history to scroll back into even when nothing drawn began before this week. + for (var cursor = pastWeeksFrom; cursor < pastDaysFrom; cursor = cursor.AddDays(7)) { columns.Add(Week(cursor, cursor.Month != previousMonth)); previousMonth = cursor.Month; previousYear = cursor.Year; } - // This week, a column a day. The first carries the week's number, so the - // reader still knows which week this is without a column of its own. - for (var cursor = thisWeek; cursor < weeksFrom; cursor = cursor.AddDays(1)) + // Last week, this week and next, a column a day. The first day of each week + // carries its number, so the reader still knows which week it is without a + // column of its own. + for (var cursor = pastDaysFrom; cursor < weeksFrom; cursor = cursor.AddDays(1)) { + var week = StartOfWeek(cursor, weekStart); + columns.Add(new RoadmapColumn( RoadmapColumnScale.Day, cursor, cursor, cursor.ToString("ddd d", CultureInfo.CurrentCulture), - cursor == thisWeek ? $"W{WeekNumber(thisWeek, weekStart)}" : null, + cursor == week ? $"W{WeekNumber(week, weekStart)}" : null, cursor.ToString("dddd d MMMM yyyy", CultureInfo.CurrentCulture))); } - previousMonth = thisWeek.Month; - previousYear = thisWeek.Year; + // The days name no month, so the first week after them names its own unless + // the last day-week already began in it. + previousMonth = weeksFrom.AddDays(-7).Month; + previousYear = weeksFrom.AddDays(-7).Year; for (var cursor = weeksFrom; cursor < monthsFrom && cursor <= end; cursor = cursor.AddDays(7)) { @@ -208,17 +234,19 @@ public static RoadmapWindow Graduated(IEnumerable dates, DateOnly toda for (var cursor = quartersFrom; cursor <= end; cursor = cursor.AddMonths(3)) { - columns.Add(new RoadmapColumn( - RoadmapColumnScale.Quarter, - cursor, - EndOfQuarter(cursor), - $"Q{QuarterOf(cursor)}", - cursor.Year.ToString(CultureInfo.InvariantCulture), - $"Q{QuarterOf(cursor)} {cursor.Year}")); + columns.Add(Quarter(cursor)); } return new RoadmapWindow(columns); + static RoadmapColumn Quarter(DateOnly start) => new( + RoadmapColumnScale.Quarter, + start, + EndOfQuarter(start), + $"Q{QuarterOf(start)}", + start.Year.ToString(CultureInfo.InvariantCulture), + $"Q{QuarterOf(start)} {start.Year}"); + RoadmapColumn Week(DateOnly start, bool showMonth) => new( RoadmapColumnScale.Week, start, diff --git a/tests/Backlog.UI.Components.UnitTests/RoadmapGraduatedAxisTests.cs b/tests/Backlog.UI.Components.UnitTests/RoadmapGraduatedAxisTests.cs index bedaf35fe..a47da9e9f 100644 --- a/tests/Backlog.UI.Components.UnitTests/RoadmapGraduatedAxisTests.cs +++ b/tests/Backlog.UI.Components.UnitTests/RoadmapGraduatedAxisTests.cs @@ -3,20 +3,20 @@ namespace Backlog.UI.Components.UnitTests; /// -/// The graduated axis: this week a column a day, three weeks after it, months for -/// about three after, quarters beyond — and history before it, weeks and then -/// months. Pinned as columns and distances, because a ruler that changes scale is -/// only honest if every column meets the next exactly and a day is wider near -/// today than a year out. +/// The graduated axis, the same both ways from today: last week, this week and next +/// a column a day, three weeks either side of those, months for about a quarter +/// beyond, quarters beyond that. Pinned as columns and distances, because a ruler +/// that changes scale is only honest if every column meets the next exactly and a +/// day is wider near today than a year out. /// public sealed class RoadmapGraduatedAxisTests { - // Friday 25 September 2026. Its week starts on Monday the 21st and is ruled a - // day a column; the weeks run from the 28th, and four weeks from the 21st is - // Monday 19 October, where the months take over — the rest of October as a - // column of its own — and the first quarter start three months after that is - // 1 April 2027. Four weeks back is Monday 24 August, where history turns from - // weeks to months. + // Friday 25 September 2026. Its week starts on Monday the 21st; the days run + // from Monday 14 September to Sunday 4 October. Forward, the weeks run from + // 5 October to Monday 26 October, where the months take over — the rest of + // October as a column of its own — and the first quarter start three months + // after that is 1 April 2027. Backward, the weeks run from Monday 24 August, + // the months before that from 1 April 2026, and quarters before that. private static readonly DateOnly Today = new(2026, 9, 25); private static RoadmapWindow Window(params DateOnly[] dates) => @@ -37,16 +37,16 @@ public void Days_ThenWeeks_ThenMonths_ThenQuarters_EachTierStartingOnABoundaryOf var months = window.Columns.Where(column => column.Scale == RoadmapColumnScale.Month).ToList(); var quarters = window.Columns.Where(column => column.Scale == RoadmapColumnScale.Quarter).ToList(); - Assert.Equal(7, days.Count); + Assert.Equal(21, days.Count); Assert.All(days, day => Assert.Equal(1, day.TotalDays)); - Assert.Equal(new DateOnly(2026, 9, 21), days[0].Start); - Assert.Equal(new DateOnly(2026, 9, 27), days[^1].End); + Assert.Equal(new DateOnly(2026, 9, 14), days[0].Start); + Assert.Equal(new DateOnly(2026, 10, 4), days[^1].End); Assert.Equal(RoadmapWindow.GraduatedWeeks, history.Count); - Assert.Equal(RoadmapWindow.GraduatedWeeks - 1, weeks.Count); + Assert.Equal(RoadmapWindow.GraduatedWeeks, weeks.Count); Assert.All(weeks, week => Assert.Equal(7, week.TotalDays)); - Assert.Equal(new DateOnly(2026, 10, 18), weeks[^1].End); - Assert.Equal(new DateOnly(2026, 10, 19), months[0].Start); + Assert.Equal(new DateOnly(2026, 10, 25), weeks[^1].End); + Assert.Equal(new DateOnly(2026, 10, 26), months[0].Start); Assert.Equal(new DateOnly(2026, 10, 31), months[0].End); Assert.Equal([10, 11, 12, 1, 2, 3], months.Select(month => month.Start.Month)); Assert.All(months.Skip(1), month => Assert.Equal(1, month.Start.Day)); @@ -69,7 +69,7 @@ public void AShortPlan_StillShowsTheWholeWeeklyAndMonthlyHorizon() } [Fact] - public void LongAgo_IsRuledInMonths_ThenTheFourWeeksBeforeThisOne_InWeeks() + public void RecentHistory_IsRuledInMonths_ThenThreeWeeks_ThenLastWeeksDays() { var window = Window(new DateOnly(2026, 8, 10), new DateOnly(2026, 11, 1)); @@ -79,30 +79,48 @@ public void LongAgo_IsRuledInMonths_ThenTheFourWeeksBeforeThisOne_InWeeks() var history = window.Columns.Skip(1).TakeWhile(column => column.Scale == RoadmapColumnScale.Week).ToList(); Assert.Equal( - [new DateOnly(2026, 8, 24), new DateOnly(2026, 8, 31), new DateOnly(2026, 9, 7), new DateOnly(2026, 9, 14)], + [new DateOnly(2026, 8, 24), new DateOnly(2026, 8, 31), new DateOnly(2026, 9, 7)], history.Select(week => week.Start)); Assert.Equal(RoadmapColumnScale.Day, window.Columns[1 + history.Count].Scale); - Assert.Equal(new DateOnly(2026, 9, 21), window.Columns[1 + history.Count].Start); + Assert.Equal(new DateOnly(2026, 9, 14), window.Columns[1 + history.Count].Start); AssertContiguous(window); } [Fact] - public void RecentHistory_AlwaysOffersTheFourWeeksBeforeThisOne_EvenWhenNothingStartedThen() + public void LongAgo_IsRuledInQuarters_ThenWholeMonthsFromAQuarterStart() { - // Nothing drawn before this week: the four weeks before it are still there to - // scroll back into, from Monday 24 August, and nothing earlier. + // The mirror of the horizon: months for at least a quarter before the + // weeks, beginning on a quarter start, and quarters before that. + var window = Window(new DateOnly(2025, 11, 10), new DateOnly(2026, 11, 1)); + + var quarters = window.Columns.TakeWhile(column => column.Scale == RoadmapColumnScale.Quarter).ToList(); + Assert.Equal(["Q4 2025", "Q1 2026"], quarters.Select(quarter => quarter.LongLabel)); + Assert.Equal(new DateOnly(2025, 10, 1), window.Start); + + var months = window.Columns.Skip(quarters.Count).TakeWhile(column => column.Scale == RoadmapColumnScale.Month).ToList(); + Assert.Equal([4, 5, 6, 7, 8], months.Select(month => month.Start.Month)); + Assert.All(months, month => Assert.Equal(1, month.Start.Day)); + Assert.Equal(new DateOnly(2026, 8, 23), months[^1].End); + AssertContiguous(window); + } + + [Fact] + public void RecentHistory_AlwaysOffersThreeWeeksAndLastWeeksDays_EvenWhenNothingStartedThen() + { + // Nothing drawn before this week: the weeks and days before it are still + // there to scroll back into, from Monday 24 August, and nothing earlier. var window = Window(new DateOnly(2026, 9, 24), new DateOnly(2026, 11, 1)); Assert.Equal(new DateOnly(2026, 8, 24), window.Start); Assert.Equal( - [RoadmapColumnScale.Week, RoadmapColumnScale.Week, RoadmapColumnScale.Week, RoadmapColumnScale.Week, RoadmapColumnScale.Day], - window.Columns.Take(5).Select(column => column.Scale)); + [RoadmapColumnScale.Week, RoadmapColumnScale.Week, RoadmapColumnScale.Week, RoadmapColumnScale.Day], + window.Columns.Take(4).Select(column => column.Scale)); Assert.DoesNotContain(window.Columns.TakeWhile(column => column.Start < Today), column => column.Scale == RoadmapColumnScale.Month); AssertContiguous(window); } [Fact] - public void AnEmptyPlan_StillOffersTheFourWeeksBeforeThisOne() + public void AnEmptyPlan_StillOffersTheRecentHistory() { var window = Window(); @@ -111,17 +129,17 @@ public void AnEmptyPlan_StillOffersTheFourWeeksBeforeThisOne() } [Fact] - public void ThisWeeksDays_AreNamedByWeekday_TheFirstCarryingTheWeekNumber() + public void TheDays_RunFromLastWeekToNext_EachWeeksFirstCarryingItsNumber() { var days = Window(new DateOnly(2026, 10, 1)).Columns .Where(column => column.Scale == RoadmapColumnScale.Day) .ToList(); - // Monday 21 September 2026 opens ISO week 39. - Assert.Equal("W39", days[0].Caption); - Assert.All(days.Skip(1), day => Assert.Null(day.Caption)); - Assert.EndsWith("21", days[0].Label); - Assert.EndsWith("27", days[^1].Label); + // Mondays 14, 21 and 28 September 2026 open ISO weeks 38, 39 and 40. + Assert.Equal(["W38", "W39", "W40"], days.Where(day => day.Caption is not null).Select(day => day.Caption)); + Assert.Equal([0, 7, 14], days.Select((day, index) => (day, index)).Where(pair => pair.day.Caption is not null).Select(pair => pair.index)); + Assert.EndsWith("14", days[0].Label); + Assert.EndsWith("4", days[^1].Label); } [Fact] @@ -131,11 +149,12 @@ public void AWeekHead_IsItsWeekNumber_AndNamesTheMonthOnlyWhereTheMonthChanges() .Where(column => column.Scale == RoadmapColumnScale.Week && column.Start > Today) .ToList(); - // The week after this one, still in September, so no month under it. - Assert.Equal("W40", weeks[0].Label); - Assert.Equal("W41", weeks[1].Label); - Assert.Null(weeks[0].Caption); - Assert.NotNull(weeks.Single(week => week.Start == new DateOnly(2026, 10, 5)).Caption); + // The first week after the days enters October, which no day names; the + // next is still in it. + Assert.Equal("W41", weeks[0].Label); + Assert.Equal("W42", weeks[1].Label); + Assert.NotNull(weeks[0].Caption); + Assert.Null(weeks[1].Caption); } [Fact] @@ -175,10 +194,10 @@ public void EveryWholeDay_Week_Month_AndQuarter_IsDrawnTheSameWidth() // February and March, 28 and 31 days, are one width. Assert.Contains(window.Columns, column => column.Start == new DateOnly(2027, 2, 1)); - // The rest of October after the fourth week is its share of a month. + // The rest of October after the weeks is its share of a month. var october = window.Columns.First(column => column.Scale == RoadmapColumnScale.Month); - Assert.Equal(13, october.TotalDays); - Assert.Equal(geometry.ColumnWidthRem(RoadmapColumnScale.Month) * 13 / 31, geometry.WidthFor(october.Start, october.End), 6); + Assert.Equal(6, october.TotalDays); + Assert.Equal(geometry.ColumnWidthRem(RoadmapColumnScale.Month) * 6 / 31, geometry.WidthFor(october.Start, october.End), 6); } [Fact] @@ -196,9 +215,9 @@ public void ColumnsMeetEdgeToEdge_AndTheTrackEndsWhereTheLastColumnDoes() Assert.Equal(geometry.XFor(window.End.AddDays(1)), geometry.TrackWidthRem, 6); // A bar spanning two tiers is as wide as its share of each. - var across = geometry.WidthFor(new DateOnly(2026, 10, 12), new DateOnly(2026, 10, 25)); + var across = geometry.WidthFor(new DateOnly(2026, 10, 19), new DateOnly(2026, 10, 31)); Assert.Equal( - geometry.ColumnWidthRem(RoadmapColumnScale.Week) + geometry.ColumnWidthRem(RoadmapColumnScale.Month) * 7 / 31, + geometry.ColumnWidthRem(RoadmapColumnScale.Week) + geometry.ColumnWidthRem(RoadmapColumnScale.Month) * 6 / 31, across, 6); } @@ -211,14 +230,11 @@ public void AGraduatedTimeline_RulesThisWeekInDays_AndNamesAGroupOnce() var view = RenderPlan(context); - Assert.Equal(7, view.FindAll(".roadmap-timeline__quarter--day").Count); - // Four weeks of history before this week, three after it. - Assert.Equal(7, view.FindAll(".roadmap-timeline__quarter--week").Count); + // Last week, this week and next in days; three weeks either side of them. + Assert.Equal(21, view.FindAll(".roadmap-timeline__quarter--day").Count); + Assert.Equal(6, view.FindAll(".roadmap-timeline__quarter--week").Count); Assert.Equal(6, view.FindAll(".roadmap-timeline__quarter--month").Count); - - // The rest of October, though under a fortnight, is still wide enough to be named. - Assert.Equal(1, view.FindAll(".roadmap-timeline__quarter--month")[0].QuerySelectorAll(".roadmap-timeline__quarter-label").Length); - // Where history's weeks meet this week's days, then weeks, then months. + // Where history's weeks meet the days, then weeks, then months. Assert.Equal(3, view.FindAll(".roadmap-timeline__rule--scale").Count); // One label column row per track row, the group named once, and the lane @@ -241,7 +257,7 @@ public void AGraduatedTimeline_RulesThisWeekInDays_AndNamesAGroupOnce() } [Fact] - public void AMeasuredScroller_StretchesTheChart_SoFromThisWeekOnItFillsTheWidth() + public void AMeasuredScroller_StretchesTheChart_SoFromLastWeekOnItFillsTheWidth() { using var context = new BunitContext(); context.JSInterop.Mode = JSRuntimeMode.Loose; @@ -252,7 +268,7 @@ public void AMeasuredScroller_StretchesTheChart_SoFromThisWeekOnItFillsTheWidth( var history = LeftOf(view.Find(".roadmap-timeline__quarter--day").GetAttribute("style")!); var shown = natural - history; - // Wider than the chart from this week on: every column widens by the same + // Wider than the chart from last week on: every column widens by the same // factor until that stretch is exactly the scroller's width — the history to // its left widening with it — and the days name their weekdays. view.InvokeAsync(() => view.Instance.Measured(shown * 2)); @@ -267,7 +283,7 @@ public void AMeasuredScroller_StretchesTheChart_SoFromThisWeekOnItFillsTheWidth( } [Fact] - public void AMeasuredScroller_OpensOnThisWeek_WithHistoryToTheLeft() + public void AMeasuredScroller_OpensOnLastWeek_WithOlderHistoryToTheLeft() { using var context = new BunitContext(); context.JSInterop.Mode = JSRuntimeMode.Loose;