/* Trial Calendar — the view the Content Center lives in to make coverage calls.
Day, Week and Month views of courtroom activity. Week and Month are the grid
the team knew from Airtable: multi-day trials render as a single continuous bar
that crosses the days it covers; single-day events sit on their day. Day is a
time axis in EASTERN time (L&C's zone) — court times are stored in the court's
own zone and converted by window.LedgerTime, and every screen says which zone
it is showing. Colors match the team's current calendar.
A separate tab lists tracked matters with NO court date set yet — the watchlist
they keep so they remember to keep checking the court calendar.
Assigns window.LedgerTrialCalendar. */
(function () {
const DS = window.LawCrimeDesignSystem_e18d68;
const T = window.titleize;
const icons = () => setTimeout(() => window.lucide && window.lucide.createIcons(), 30);
// Date helpers and the Day/Week/Month navigation come from the shared kit
// (CalendarKit.jsx); this file keeps what is particular to court activity.
const CK = window.LedgerCalendarKit;
const { iso, parseISO, addDays, MONTHS, DOW } = CK;
const WEEKEND_KEY = "ledger.trialCalendar.showWeekends";
const MAX_LANES = 4; // event rows shown per week (month view) before a day collapses to "+N"
// Event type -> the team's existing calendar categories + colors (see .cal-ev--* / .cal-dot--*).
const CAT_OF = {
trial_start: "trial", trial_day: "trial",
hearing: "hearing",
sentencing: "sentencing",
bail_hearing: "pretrial",
arraignment: "arraignment",
motion_hearing: "motion",
change_of_plea: "plea",
};
const CAT_META = {
trial: { label: "Trial" }, hearing: { label: "Hearing" }, sentencing: { label: "Sentencing" },
pretrial: { label: "Pre-trial" }, arraignment: { label: "Arraignment" }, motion: { label: "Motion hearing" },
plea: { label: "Change of plea" }, other: { label: "Other" },
};
const LEGEND = ["trial", "hearing", "sentencing", "plea", "pretrial", "arraignment", "motion", "other"];
const category = (e) => CAT_OF[e.event_type] || "other";
// The "Trials & sentencings only" filter keeps the ones the team watches most closely.
// A change of plea belongs here: it is the day a trial they were planning to cover
// stops happening, which is exactly when the desk needs to know.
const isKey = (e) => { const c = category(e); return c === "trial" || c === "sentencing" || c === "plea"; };
const endOf = (e) => (e.end_date && e.end_date >= e.event_date) ? e.end_date : e.event_date;
const matterName = (e) => (e.matters && e.matters.working_title) || "Untitled matter";
// Eastern-time view of an event's start (null when it has no time). Computed once
// per load in CalendarGrid and carried on the row as `e.et`.
const withET = (e) => ({ ...e, et: window.LedgerTime.toEastern(e.event_date, e.event_time, e.matters && e.matters.crime_location_state) });
// Compact time for a bar or list: "11:30 AM" (ET) or "9:00 AM local" when the
// court's zone is unknown, so it is never passed off as Eastern.
const etShort = (et) => !et ? "" : et.known ? et.short : et.short + " local";
const etTitle = (et) => !et ? "" : [et.known ? et.label : null, et.courtLabel ? "court " + et.courtLabel : null, et.note].filter(Boolean).join(" · ");
const HOUR_PX = 64; // day view: one hour of the time axis
const SLOT_MIN = 60; // an event has no end time; it is drawn as one hour
// ---- Calendar grid (day, week or month) ---------------------------------
function CalendarGrid({ onOpenMatter }) {
// DEFAULT IS THE WEEK (operator, 2026-09-18). This reverses 2026-07-10, when
// the default moved to Month at the Content Center's request (Sara Burns:
// "change the default to the month, not the day"). Week is the working horizon
// for coverage calls; Month is one click away and still the overview.
// Weekends hidden by default (Lacey, 2026-10-01: "no reason for it"); the choice
// is remembered per browser. Hidden weekend events are never silently dropped:
// they roll up into a "+N weekend" marker on Friday.
const nav = CK.useCalendarNav({ defaultView: "week", weekendKey: WEEKEND_KEY, weekendDefault: false });
const { view, cursor, isDay, isWeek, showWeekends, setShowWeekends, nCols, colStyle, cells, weeks, dowRow, gridStart } = nav;
const cellCount = cells.length;
const [events, setEvents] = React.useState(null);
const [err, setErr] = React.useState(null);
const [keyOnly, setKeyOnly] = React.useState(false);
const [coveredOnly, setCoveredOnly] = React.useState(false);
// "Mine" (0159, B3): matters whose Content Center owner is the signed-in user.
// Offered to Content Ops only, and only once their staff id resolves.
const [myStaff, setMyStaff] = React.useState(null);
const [mineOnly, setMineOnly] = React.useState(false);
React.useEffect(() => {
const caps = window.LedgerCaps || {};
if (caps.isContentOps || caps.isAdmin) window.LedgerAPI.myStaffIdAnyDomain().then(setMyStaff).catch(() => {});
}, []);
const isMine = (e) => !!(myStaff && e.matters && e.matters.cc_assignee_staff_id === myStaff);
const [covDefaults, setCovDefaults] = React.useState({});
const [selDay, setSelDay] = React.useState(null);
// Move a court date from the day list (0158): { e, date, end, time, reason, busy, err }.
const [moving, setMoving] = React.useState(null);
// Matter-default coverage per matter (id -> {ingest_method, feed_location, ...}),
// fetched once; lets the calendar denote what we're covering and how.
React.useEffect(() => { window.LedgerAPI.coverageDefaults().then(setCovDefaults).catch(() => {}); }, []);
const isCovered = (e) => !!(e.matters && e.matters.coverage_status === "assigned");
// Covering vs Tracking (B4, Lacey 2026-10-22): Covering is a solid bar in the
// type's color, everything else (Tracking, adjudicated, unset) is an outline.
const covCls = (e) => (isCovered(e) ? " is-cov" : " is-trk");
const covMethod = (e) => { const cd = covDefaults[e.matter_id]; return cd && cd.ingest_method; };
const methodShort = (window.LedgerCoverageUtil && window.LedgerCoverageUtil.methodShort) || ((m) => T(m));
// Week view shows every lane (there's vertical room); month caps at MAX_LANES.
const maxLanes = isWeek ? 99 : MAX_LANES;
// "Today" is today in EASTERN, the zone the whole calendar is read in.
const todayISO = nav.today;
const etAbbr = window.LedgerTime.homeAbbr(iso(cursor));
const load = React.useCallback(() => {
setEvents(null); setErr(null);
window.LedgerAPI.listCalendarEvents(iso(cells[0]), iso(cells[cells.length - 1]))
.then((rows) => setEvents(rows.map(withET))).catch((e) => setErr(e.message || String(e)));
}, [iso(gridStart), cellCount]);
React.useEffect(() => { load(); }, [load]);
React.useEffect(() => { icons(); }, [events, selDay, keyOnly, coveredOnly, covDefaults, view, moving && moving.e.event_id]);
const isSpan = (e) => e.event_type === "trial_start" || e.event_type === "trial_day";
function startMove(e) {
setMoving({ e, date: e.event_date, end: isSpan(e) ? (e.end_date || "") : "",
time: (e.event_time || "").slice(0, 5), reason: "", busy: false, err: null });
}
async function saveMove() {
const m = moving;
if (!m.date) { setMoving({ ...m, err: "Pick a date." }); return; }
if (m.end && m.end < m.date) { setMoving({ ...m, err: "End date can’t be before the start date." }); return; }
setMoving({ ...m, busy: true, err: null });
try {
await window.LedgerAPI.moveCaseEvent(m.e.event_id, { date: m.date, endDate: isSpan(m.e) ? m.end : null, time: m.time, reason: m.reason });
setMoving(null);
// The event may have left this day (or this view): follow it there.
if (m.date !== selDay) setSelDay(null);
load();
} catch (err) { setMoving({ ...m, busy: false, err: err.message || String(err) }); }
}
const shownEvents = React.useMemo(
() => (events || []).filter((e) => (!keyOnly || isKey(e)) && (!coveredOnly || isCovered(e)) && (!mineOnly || isMine(e))), [events, keyOnly, coveredOnly, mineOnly, myStaff]);
// Lay one week out: each event becomes a horizontal segment spanning the
// columns it covers within the week, packed into lanes so they don't overlap.
function layoutWeek(weekDays) {
const wStartISO = iso(weekDays[0]), wEndISO = iso(weekDays[6]);
const segs = [];
let weekend = 0; // events living only on this week's hidden Sat/Sun
shownEvents.forEach((e) => {
const evEndISO = endOf(e);
if (e.event_date > wEndISO || evEndISO < wStartISO) return; // no overlap with this week
const segStartISO = e.event_date < wStartISO ? wStartISO : e.event_date;
const segEndISO = evEndISO > wEndISO ? wEndISO : evEndISO;
const startCol = weekDays.findIndex((d) => iso(d) === segStartISO);
let endCol = weekDays.findIndex((d) => iso(d) === segEndISO);
let contR = evEndISO > wEndISO;
if (startCol >= nCols) { weekend++; return; } // Sat/Sun only → Friday marker
if (endCol >= nCols) { endCol = nCols - 1; contR = true; } // runs into the weekend
segs.push({ e, startCol, endCol, span: endCol - startCol + 1,
contL: e.event_date < wStartISO, contR, multi: evEndISO !== e.event_date });
});
// Covering first (Lacey 2026-10-15), so what we cover takes the top lanes and is
// never the one pushed into a month cell's "+N". Then longest/earliest first →
// stable lanes (a trial keeps the top lane across the week). Then by Eastern
// start time, so a day's single events read top-to-bottom in the order they happen.
segs.sort((a, b) => (isCovered(b.e) - isCovered(a.e)) || (b.span - a.span) || (a.startCol - b.startCol) || (isKey(b.e) - isKey(a.e)) || (etMin(a.e) - etMin(b.e)));
const lanes = [];
segs.forEach((s) => {
let lane = 0;
for (; ; lane++) {
const occ = lanes[lane] || (lanes[lane] = []);
if (!occ.some((o) => !(s.endCol < o.startCol || s.startCol > o.endCol))) { occ.push(s); s.lane = lane; break; }
}
});
// Days where some segment was pushed past the visible lanes → show a "+N".
const hidden = {};
segs.forEach((s) => { if (s.lane >= maxLanes) for (let c = s.startCol; c <= s.endCol; c++) hidden[c] = (hidden[c] || 0) + 1; });
return { segs: segs.filter((s) => s.lane < maxLanes), laneCount: Math.min(lanes.length, maxLanes), hidden, weekend };
}
// Ordered by EASTERN time — sorting the raw court-local time would put an
// 8:30 PT hearing (11:30 ET) ahead of a 9:00 ET one.
const etMin = (e) => (e.et && e.et.known ? e.et.minutes : 1e9);
const dayEvents = (dayISO) => shownEvents
.filter((e) => e.event_date <= dayISO && endOf(e) >= dayISO)
.sort((a, b) => (isCovered(b) - isCovered(a)) || (isKey(b) - isKey(a)) || (etMin(a) - etMin(b)));
const openDay = (dayISO) => { setSelDay(null); nav.goTo(dayISO); nav.setView("day"); };
// In week view there's room for the time (Eastern); show it on the bar's start day.
const barLabel = (s) => {
const base = (s.contL ? "… " : "") + CAT_META[category(s.e)].label + " · " + matterName(s.e);
return (isWeek && !s.contL && s.e.et) ? etShort(s.e.et) + " · " + base : base;
};
const selEvents = selDay ? dayEvents(selDay) : [];
return (
setSelDay(null)}>
{myStaff && (
)}
{LEGEND.map((c) => {CAT_META[c].label})}
Covering Tracking
Times in Eastern ({etAbbr})
Ledger keeps this date from now on. Moving it in Airtable won't change it here.{moving.busy ? "Moving…" : "Move"}
)}
))}
)}
);
}
// ---- Day view: an Eastern time axis ---------------------------------------
// Each timed event sits at its EASTERN start time. There is no end time in the
// data, so every block is drawn as one hour and says so; events whose hours
// overlap share the row side by side. Placed on the axis only on the day the
// time belongs to (a multi-day trial's later days have no recorded time), and
// only when the court's zone is known — otherwise the time is the court's own
// clock and cannot be placed on an Eastern axis honestly.
function DayView({ dayISO, events, todayISO, etAbbr, onOpenMatter, isCovered, covMethod, methodShort }) {
React.useEffect(() => { icons(); });
// Re-render every minute so the "now" line moves.
const [, tick] = React.useState(0);
// The strip is capped: on live data (2026-09-18) 42 of a day's 61 events had no
// time — mostly later days of multi-day trials — and listing them all pushed the
// time axis off the first screen. Reset when the day changes.
const [allUntimed, setAllUntimed] = React.useState(false);
React.useEffect(() => { setAllUntimed(false); }, [dayISO]);
React.useEffect(() => { const t = setInterval(() => tick((n) => n + 1), 60000); return () => clearInterval(t); }, []);
if (events === null) return null;
const timed = [], untimed = [];
events.forEach((e) => {
if (e.et && e.et.known && e.event_date === dayISO) timed.push(e); else untimed.push(e);
});
timed.sort((a, b) => a.et.minutes - b.et.minutes);
// What matters most first: events we are covering, then trials/sentencings/pleas,
// then things that START today ahead of a trial's later days.
untimed.sort((a, b) => (isCovered(b) - isCovered(a)) || (isKey(b) - isKey(a))
|| ((a.event_date === dayISO ? 0 : 1) - (b.event_date === dayISO ? 0 : 1))
|| matterName(a).localeCompare(matterName(b)));
const UNTIMED_CAP = 8;
const untimedShown = allUntimed ? untimed : untimed.slice(0, UNTIMED_CAP);
// Visible hours: 7 AM–7 PM ET, widened to fit anything earlier or later.
const mins = timed.map((e) => Math.min(e.et.minutes, 1439));
const startH = Math.max(0, Math.min(7, ...mins.map((m) => Math.floor(m / 60))));
const endH = Math.min(24, Math.max(19, ...mins.map((m) => Math.ceil((m + SLOT_MIN) / 60))));
const top = (m) => ((m - startH * 60) / 60) * HOUR_PX;
// Side-by-side columns for overlapping one-hour blocks: group into clusters of
// mutually overlapping events, then give each event the first free column.
const placed = [];
let cluster = [], clusterEnd = -1;
const flush = () => {
const cols = [];
cluster.forEach((p) => {
let c = 0; while (cols[c] != null && cols[c] > p.m) c++;
cols[c] = p.m + SLOT_MIN; p.col = c;
});
cluster.forEach((p) => { p.cols = cols.length; placed.push(p); });
cluster = []; clusterEnd = -1;
};
timed.forEach((e) => {
const m = Math.min(e.et.minutes, 1439);
if (cluster.length && m >= clusterEnd) flush();
cluster.push({ e, m }); clusterEnd = Math.max(clusterEnd, m + SLOT_MIN);
});
if (cluster.length) flush();
const hours = []; for (let h = startH; h < endH; h++) hours.push(h);
const isToday = dayISO === todayISO;
const nowM = window.LedgerTime.nowEasternMinutes();
const showNow = isToday && nowM >= startH * 60 && nowM <= endH * 60;
const dayNo = (e) => Math.round((parseISO(dayISO) - parseISO(e.event_date)) / 86400000) + 1;
const covCls = (e) => (isCovered(e) ? " is-cov" : " is-trk");
const covWord = (e) => (isCovered(e) ? "Covering" + (covMethod(e) ? " · " + methodShort(covMethod(e)) : "") : "Tracking");
return (
All times Eastern ({etAbbr}). Courts record times in their own zone; each is converted, and the court’s own time is shown where it differs.
);
}
// ---- Awaiting-court-date watchlist ---------------------------------------
function AwaitingTab({ onOpenMatter }) {
const [rows, setRows] = React.useState(null);
const [total, setTotal] = React.useState(null);
const [err, setErr] = React.useState(null);
const LIMIT = 200;
React.useEffect(() => {
// ~1,400 matters qualify now, so the list is capped and the true count is
// read separately — never silently truncated.
window.LedgerAPI.listAwaitingCourtDate({ limit: LIMIT })
.then(setRows).catch((e) => setErr(e.message || String(e)));
window.LedgerAPI.awaitingCourtDateCount().then(setTotal).catch(() => {});
}, []);
React.useEffect(() => { icons(); }, [rows]);
return (
No court date set yet — tracked matters with nothing on the calendar. Keep checking the court
calendar; when a date lands, add it under the matter’s Case events tab and it moves onto the grid.
Automation candidate — watch dockets and flag new dates.
{err &&
{err}
}
{rows && total != null && total > rows.length && (
Showing the first {rows.length.toLocaleString()} of {total.toLocaleString()} — narrow by state or status on the Matters list to work through the rest.
)}
{rows === null &&
Loading…
}
{rows && rows.length === 0 && (
Nothing waitingEvery tracked matter has a court date on the calendar.