jcoffey-dev
f7712b1c1e
web/src/lib had grown to 85 flat modules -- 42% of the web source, about
12,800 lines -- with one subdirectory (smime/) to its name. The tell was
that a naming prefix had taken over a directory's job: eight adminX.ts
files sat adjacent because alphabetical order put them there, not because
anything said they belonged together.
lib/admin/ adminAccess, adminDashboard, adminDirectory, adminDomains,
adminGroups, adminLists, adminRoles, adminTenants
lib/calendar/ appointment, availabilityWindow, eventDrag, ics, recurrence
Tests move with their modules into lib/admin/__tests__ and
lib/calendar/__tests__, which is what views/ already does. describeRules
stays in lib/__tests__: it checks that sieve's describeRule and
recurrence's agree, so it belongs to neither.
recurrence.ts joins the calendar group and archiveDate.ts does not, which
is the opposite of the first guess from the filenames. archiveDate picks
the Archive/2026/09 mailbox for a message -- mail, not calendar --
while recurrence reads JSCalendarRecurrenceRule. schedule.ts is scheduled
*send*, so it stays put too. birthdays.ts is left alone deliberately: it
is read off the contact cards and only rendered by the calendar, so it
belongs to whichever of the two you ask.
docs/ held no documentation. It held ten JPEGs and the two scripts that
capture them, while the actual documentation is a separate site in the
ihasmail.org repository -- so anyone opening docs/ expecting prose found
a headless-Chrome driver. The images are now screenshots/, and the two
capture scripts join the other .mjs tooling in scripts/, which is where a
generator belongs. Renaming docs/ to screenshots/ wholesale would have
produced screenshots/screenshots/inbox-dark.jpg.
No behavior changes: every import was already on the @/ alias, so this is
path rewrites and nothing else.
114 lines
5.0 KiB
TypeScript
114 lines
5.0 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import { availabilityWindow } from "@/lib/calendar/availabilityWindow";
|
|
|
|
const at = (s: string) => new Date(s);
|
|
const hours = (w: { ticks: { time: Date }[] }) => w.ticks.map((t) => `${t.time.getDate()}@${t.time.getHours()}`);
|
|
|
|
describe("the span an availability bar covers", () => {
|
|
it("covers the whole day for an event inside one", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T10:30:00"));
|
|
expect(w.start.getHours()).toBe(0);
|
|
expect(w.days).toBe(1);
|
|
expect(w.end.getDate()).toBe(3);
|
|
expect(w.end.getHours()).toBe(0);
|
|
});
|
|
|
|
it("stretches to cover an event running over several days", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-04T17:00:00"));
|
|
expect(w.days).toBe(3);
|
|
expect(w.start.getDate()).toBe(2);
|
|
expect(w.end.getDate()).toBe(5);
|
|
});
|
|
|
|
it("ends an event on the day it ends on, not the midnight it stops at", () => {
|
|
// An all-day event on the 2nd runs to midnight starting the 3rd; it does
|
|
// not touch the 3rd and the bar should not show it.
|
|
const w = availabilityWindow(at("2026-09-02T00:00:00"), at("2026-09-03T00:00:00"));
|
|
expect(w.days).toBe(1);
|
|
expect(w.end.getDate()).toBe(3);
|
|
});
|
|
|
|
it("never collapses to nothing, even when start and end are the same moment", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T09:00:00"));
|
|
expect(w.days).toBe(1);
|
|
expect(w.span).toBeGreaterThan(0);
|
|
});
|
|
|
|
it("marks a single day every three hours, labeling every six", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T10:00:00"));
|
|
expect(w.scale).toBe("hours");
|
|
expect(hours(w)).toEqual(["2@0", "2@3", "2@6", "2@9", "2@12", "2@15", "2@18", "2@21"]);
|
|
expect(w.ticks.filter((t) => t.major).map((t) => t.time.getHours())).toEqual([0, 6, 12, 18]);
|
|
});
|
|
|
|
it("thins the marks out to every six hours across two days", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-03T10:00:00"));
|
|
expect(w.scale).toBe("hours");
|
|
expect(hours(w)).toEqual(["2@0", "2@6", "2@12", "2@18", "3@0", "3@6", "3@12", "3@18"]);
|
|
});
|
|
|
|
it("marks day boundaries once there are more than two", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-05T10:00:00"));
|
|
expect(w.scale).toBe("days");
|
|
expect(hours(w)).toEqual(["2@0", "3@0", "4@0", "5@0"]);
|
|
expect(w.ticks.every((t) => t.major)).toBe(true);
|
|
});
|
|
|
|
it("puts every mark at its true fraction of the span", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T10:00:00"));
|
|
expect(w.ticks[0]!.at).toBe(0);
|
|
expect(w.ticks[4]!.at).toBeCloseTo(0.5, 5); // noon
|
|
expect(w.ticks.every((t) => t.at >= 0 && t.at < 1)).toBe(true);
|
|
});
|
|
|
|
it("stops at a week and says how much it left out", () => {
|
|
const w = availabilityWindow(at("2026-09-01T09:00:00"), at("2026-09-30T17:00:00"));
|
|
expect(w.days).toBe(7);
|
|
expect(w.daysHidden).toBe(23);
|
|
});
|
|
|
|
it("hides nothing when the event fits", () => {
|
|
expect(availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-04T17:00:00")).daysHidden).toBe(0);
|
|
});
|
|
|
|
it("lands on real midnights, and measures the span between them", () => {
|
|
/*
|
|
* The span is what every position is a fraction of, so it has to be the
|
|
* distance between the two boundaries rather than a count of 24-hour days:
|
|
* on the day a clock changes those differ by an hour, which would end the
|
|
* bar early and put every block after the change in the wrong place. This
|
|
* asserts the relationship; whether the run happens to sit in a zone with
|
|
* DST is not something a test should depend on.
|
|
*/
|
|
for (const day of ["2026-03-29", "2026-10-25", "2026-09-02"]) {
|
|
const w = availabilityWindow(at(`${day}T09:00:00`), at(`${day}T10:00:00`));
|
|
expect(w.start.getHours(), day).toBe(0);
|
|
expect(w.end.getHours(), day).toBe(0);
|
|
expect(w.span, day).toBe(w.end.getTime() - w.start.getTime());
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("looking around the event without changing it", () => {
|
|
it("slides the whole window forward, keeping its width", () => {
|
|
const here = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-04T17:00:00"));
|
|
const later = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-04T17:00:00"), { offsetDays: 3 });
|
|
expect(later.days).toBe(here.days);
|
|
expect(later.start.getDate()).toBe(5);
|
|
expect(later.end.getDate()).toBe(8);
|
|
});
|
|
|
|
it("slides backwards, across the end of a month", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T10:00:00"), { offsetDays: -3 });
|
|
expect(w.start.getMonth()).toBe(7); // August
|
|
expect(w.start.getDate()).toBe(30);
|
|
expect(w.days).toBe(1);
|
|
});
|
|
|
|
it("keeps the marks in step with where the window moved to", () => {
|
|
const w = availabilityWindow(at("2026-09-02T09:00:00"), at("2026-09-02T10:00:00"), { offsetDays: 1 });
|
|
expect(w.ticks[0]!.time.getDate()).toBe(3);
|
|
expect(w.ticks[0]!.at).toBe(0);
|
|
});
|
|
});
|