@umriss-ui/schedule 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,560 @@
+import { CalendarInput } from '@umriss-ui/charts';
+import { CSSProperties } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+
+/** The subtask as the intent asks for it. An intent for another subtask leaves
+ it as it is. */
+export declare function applyIntent<S extends Subtask>(subtask: S, intent: Intent): S;
+
+/** When a transport has to have arrived at its subtask, by its anchor. */
+export declare function arrival(transport: Transport, to: Subtask): number;
+
+/** When a transport leaves its subtask, by its anchor. */
+export declare function departure(transport: Transport, from: Subtask): number;
+
+/** Both kinds of finding over the same data. */
+export declare interface Findings {
+    readonly overlaps: readonly Overlap[];
+    readonly lateTransports: readonly LateTransport[];
+}
+
+/** Overlaps and late transports at once. */
+export declare function findings(subtasks: readonly Subtask[], transports: readonly Transport[]): Findings;
+
+/** What the schedule reports when an interaction asks for a change. Every
+ intent carries the values it asks for, not a difference: two intents of one
+ drop - a move and a lane - give the same data in either order. */
+export declare type Intent = MoveIntent | StretchIntent | SetupIntent | TeardownIntent | LaneIntent | PlaceIntent;
+
+/** The names of the intents - the editing API of the schedule. */
+export declare type IntentKind = Intent["kind"];
+
+/** One lane: a machine or station. The lanes run top to bottom in the order
+ they are declared - whichever group they are declared in. */
+export declare function Lane({ id, label }: LaneProps): null;
+
+/** A group of lanes: structure over them, and never a lane itself.
+
+ It gives its id to its children through context, so a lane never names its
+ group and a group reads in JSX as it reads in the plant. Folded, it becomes
+ one row showing a **Miniature** of everything in it; open, it shows a slim
+ head above its lanes. Which groups are folded is `collapsedGroups` on
+ `Schedule` - a view state, never an **Intent**. */
+export declare function LaneGroup({ id, label, children }: LaneGroupProps): ReactNode;
+
+export declare interface LaneGroupProps {
+    /** The group's identity - what `collapsedGroups` names. It is never a lane:
+     no subtask sits on it, no finding is reported for it, and no intent names
+     it (ADR-0025). */
+    id: string;
+    /** What the group's header says - the hall, the line, the machine group.
+     Real text, read by a screen reader; without one the header shows the id. */
+    label?: ReactNode;
+    /** `Lane`s and further `LaneGroup`s, to any depth. */
+    children?: ReactNode;
+}
+
+/** Put the subtask on another lane. */
+export declare interface LaneIntent {
+    readonly kind: "lane";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The id of the new lane. */
+    readonly lane: string;
+}
+
+export declare interface LaneProps {
+    /** The identity subtasks name in their `lane`. */
+    id: string;
+    /** What the lane header says - the machine or station. Real text, read by a
+     screen reader; without one the header shows the id. */
+    label?: ReactNode;
+}
+
+/** A transport whose duration does not fit between its anchors. */
+export declare interface LateTransport {
+    /** The id of the transport. */
+    readonly transport: string;
+    /** When it leaves, by its anchor. */
+    readonly departure: number;
+    /** When it has to have arrived, by its anchor. */
+    readonly arrival: number;
+    /** How much time is missing: departure plus duration, minus arrival. */
+    readonly shortBy: number;
+}
+
+/** Every transport whose successor is to be reached before the predecessor's
+ departure plus the transport's duration. A transport naming a subtask that
+ is not in the data is passed over: there is nothing to judge. */
+export declare function lateTransports(subtasks: readonly Subtask[], transports: readonly Transport[]): LateTransport[];
+
+/** Move the subtask in time: the main time keeps its length. */
+export declare interface MoveIntent {
+    readonly kind: "move";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new start of the main time. */
+    readonly from: number;
+    /** The new end of the main time. */
+    readonly to: number;
+}
+
+/** The interval a subtask occupies on its lane: setup and teardown included. */
+export declare function occupied(subtask: Subtask): {
+    from: number;
+    to: number;
+};
+
+/** Two subtasks covering the same time on one lane. */
+export declare interface Overlap {
+    /** The lane both sit on. */
+    readonly lane: string;
+    /** The subtask that starts earlier (setup included); on a tie, the one that
+     stands first in the data. */
+    readonly first: string;
+    /** The other one. */
+    readonly second: string;
+    /** Where the covering begins. */
+    readonly from: number;
+    /** Where it ends. */
+    readonly to: number;
+}
+
+/** Every pair of subtasks that cover each other on a lane. Touching at a
+ shared edge is not covering, and a subtask that covers no time covers
+ nothing. */
+export declare function overlaps(subtasks: readonly Subtask[]): Overlap[];
+
+/** Put work on the plan that was not on it: the answer to a drag from outside
+ the schedule (schedule-refinement 07). It carries no subtask id - there is
+ no subtask yet; the caller creates one, with its own identity, from
+ `subtaskFromPlace`. */
+export declare interface PlaceIntent {
+    readonly kind: "place";
+    /** The caller's key for the dragged item, as it declared it while dragging. */
+    readonly item: string;
+    /** The task the work belongs to. */
+    readonly task: string;
+    /** The lane it was dropped on. */
+    readonly lane: string;
+    /** Where its main time would start. */
+    readonly from: number;
+    /** Where its main time would end. */
+    readonly to: number;
+    /** The setup it was declared with. */
+    readonly setup?: number;
+    /** The teardown it was declared with. */
+    readonly teardown?: number;
+}
+
+/** What the application says it is dragging in, while it drags it
+ (schedule-refinement 07): the browser hands over the dragged data only on
+ the drop, so the ghost before the drop can only come from the caller. */
+export declare interface PlacingItem {
+    /** The caller's key for the dragged item; it comes back in the intent. */
+    readonly item: string;
+    /** The task the work belongs to. */
+    readonly task: string;
+    /** How long its main time is. */
+    readonly duration: number;
+    /** The setup it brings. */
+    readonly setup?: number;
+    /** The teardown it brings. */
+    readonly teardown?: number;
+}
+
+export declare function resolveAppearance(appearance: readonly SubtaskAppearance[] | undefined): ResolvedAppearance;
+
+/** What the drawing needs to know, with the contradiction already settled.
+
+ The four names are the ones this module was born with, and they are kept so
+ that a caller's code does not change because a picture did. Two of them are
+ now named after a drawing they no longer use, and the channel each one
+ really owns stands beside it (`sceneDraw.ts`, "ONE CHANNEL PER
+ STATEMENT"). */
+export declare interface ResolvedAppearance {
+    /** `provisional`: the FILL - none at all, so the surface shows through, with
+     a dashed outline in the task colour. Planned, not released. */
+    readonly dashed: boolean;
+    /** `fixed`: the ENDS - a cap at each end of the main time. Not a hatch any
+     more; a hatch now says "not available" of a refused lane, and the name is
+     kept only so that this type did not change with the picture. */
+    readonly hatched: boolean;
+    /** `muted`: the SATURATION - the task colour mixed half into the surface,
+     opaque and at full height. Another shift's, another crew's. */
+    readonly muted: boolean;
+    /** `open`: the FADE, where the bar passes the edge of the view. It goes on
+     past what is drawn. */
+    readonly open: boolean;
+}
+
+/** The moves that push every successor whose transport no longer fits after
+ `intent` - transitively, in the order they were first pushed. The subtask the
+ intent is about is never moved, and a cycle among the successors ends after a
+ bounded number of pushes instead of running on. */
+export declare function ripple(subtasks: readonly Subtask[], transports: readonly Transport[], intent: Intent): MoveIntent[];
+
+export declare const Schedule: ForwardRefExoticComponent<ScheduleProps & RefAttributes<ScheduleHandle>>;
+
+/** What a schedule offers a caller imperatively: the arithmetic between a
+ point on the screen and a time on a lane. Everything else is props. */
+export declare interface ScheduleHandle {
+    /** The time and the lane at a client point, or null outside the plot. */
+    positionAt: (clientX: number, clientY: number) => {
+        time: number;
+        lane: string | null;
+    } | null;
+    /** The client point of a time - on the middle of a lane where one is named -
+     or null while the schedule is not on screen. */
+    clientPointOf: (time: number, lane?: string) => {
+        x: number;
+        y: number;
+    } | null;
+    /** The visible span, as two wall-clock instants. */
+    visibleDomain: () => readonly [number, number];
+}
+
+/** What a pointer is on. */
+export declare type ScheduleHit = {
+    readonly kind: "subtask";
+    readonly subtask: Subtask;
+    readonly part: "setup" | "main" | "teardown";
+} | {
+    readonly kind: "transport";
+    readonly transport: Transport;
+} | {
+    readonly kind: "lane";
+    readonly lane: string;
+} | {
+    readonly kind: "nothing";
+};
+
+/** A pointer interaction, reported with its target and its position. */
+export declare interface ScheduleInteraction {
+    /** `"hover"` is reported when the target under the pointer changes, not on
+     every movement. */
+    readonly type: "click" | "contextmenu" | "hover";
+    /** What the pointer is on. */
+    readonly hit: ScheduleHit;
+    /** The pointer's horizontal client coordinate - where a `ContextMenu` opens. */
+    readonly clientX: number;
+    /** The pointer's vertical client coordinate. */
+    readonly clientY: number;
+    /** The wall-clock instant under the pointer. */
+    readonly time: number;
+    /** The lane under the pointer, or null below the last one. */
+    readonly lane: string | null;
+}
+
+export declare interface ScheduleProps {
+    /** What the schedule shows, for a screen reader: "Plan of week 38". */
+    ariaLabel: string;
+    /** The time in view when the schedule mounts, as two wall-clock instants.
+     Pan and zoom take it from there; a new pair of values puts it back. */
+    initialDomain: readonly [number, number];
+    /** Height in CSS pixels, both bands included. The width is the host's. */
+    height?: number;
+    /** Height of one lane in pixels. */
+    laneHeight?: number;
+    /** Width of the lane headers in pixels. */
+    headerWidth?: number;
+    /** An operating calendar: the intervals in which time counts. Nights and
+     weekends outside them are cut out of the axis. Default: the wall clock. */
+    calendar?: CalendarInput;
+    /** The narrowest and widest time span zoom may reach, in milliseconds.
+     Default: one hour to 28 days. */
+    zoomLimits?: ZoomLimits;
+    /** The raster a drag lands on: `"ticks"` - the fine band's current step -, a
+     step in milliseconds from local midnight, a step with an offset (shifts at
+     06:00, 14:00 and 22:00 are eight hours offset by six), or `false` for none.
+     It shapes the ghost and the intent, never the data. */
+    snap?: "ticks" | number | SnapRaster | false;
+    /** The intents the caller handles. Each one enables its interaction; none
+     leaves a read-only schedule (ADR-0023). */
+    intents?: readonly IntentKind[];
+    /** Whether a subtask may go to a lane. Without it every lane is open; it
+     narrows `"lane"`, it does not enable it.
+
+     Asked once per lane when a drag takes hold, and asked again at the drop.
+     The lanes it turns down are marked from the first frame of the drag - a
+     planner sees the refusal before meeting it - and over one of them the
+     ghost stays on the last lane that was allowed, the cursor says no and a
+     line ties the ghost to the pointer. A refused lane costs the lane and
+     nothing else: a drop after it still reports the move in time.
+
+     It is asked for work dragged in from outside as well, with the key and
+     task the application declared in `placing`. */
+    canMoveTo?: (subtask: Subtask, lane: string) => boolean;
+    /** Called once per intent when a drag ends. The data changes only if the
+     caller changes it. */
+    onIntent?: (intent: Intent) => void;
+    /** Click, context menu and hover, with what the pointer is on and where.
+     While it is set, a right-click opens no browser menu. */
+    onInteraction?: (interaction: ScheduleInteraction) => void;
+    /** The selected task, controlled. Leave it out and the schedule keeps the
+     selection itself. */
+    selectedTask?: string | null;
+    /** Called when a click selects a task or clears the selection, with the
+     subtask that was clicked - null where the click was on a transport or on
+     nothing. It is called again when another subtask of the same task is
+     clicked. */
+    onSelectedTaskChange?: (task: string | null, subtask: string | null) => void;
+    /** The **Lane group**s that are folded, controlled. Leave it out and the
+     schedule keeps them itself, starting from `defaultCollapsedGroups`.
+
+     Folding changes the view and not the plan, which is why it is no intent:
+     a caller that applies every intent it receives must never find a fold
+     among them (ADR-0025). A folded outer group hides the inner ones without
+     their entries leaving the list, so unfolding it gives back the view that
+     was there. */
+    collapsedGroups?: readonly string[];
+    /** Which groups are folded when the schedule mounts, where the schedule
+     keeps the state itself. Ignored while `collapsedGroups` is given. */
+    defaultCollapsedGroups?: readonly string[];
+    /** Called with the whole list when the planner folds or unfolds a group. */
+    onCollapsedGroupsChange?: (groups: readonly string[]) => void;
+    /** The visible time span after the planner panned or zoomed, as two
+     wall-clock instants - for keeping a second schedule or a chart in step. A
+     span handed in through `initialDomain` is not reported back. */
+    onDomainChange?: (domain: readonly [number, number]) => void;
+    /** What the application is dragging in from outside while it drags it - its
+     key, task, the length of its main time, its setup and teardown. The
+     browser hands the dragged data over only on the drop, so the ghost before
+     it can only come from here: set it on your own `dragstart`, clear it on
+     `dragend`. Without `"place"` in `intents` no drop is accepted. */
+    placing?: PlacingItem | null;
+    /** How the transports are drawn: a `"curve"` that leaves and arrives
+     forwards, a `"straight"` line, or `"orthogonal"` segments. A transport may
+     say otherwise for itself. */
+    route?: TransportRoute;
+    /** Where a transport's ends sit on their bars: the `"centre"` of both, or the
+     `"nearest"` edge - which is the shortest line between two stops. Within
+     one lane both mean the middle. A transport may say otherwise for itself.
+
+     It changes the picture and never a finding: whether a transport is late
+     follows from its `leaves` and `arrives` alone. */
+    attach?: TransportAttachment;
+    /** Whether a transport's two ends carry a dot (`"dot"`, the default) or the
+     line stands alone (`"none"`). The dot says where the line is anchored - a
+     help while a plan is being read, and noise in a plan full of short moves.
+     A transport may say otherwise for itself. */
+    ends?: TransportEnds;
+    /** What stands written in a bar: a function from a subtask to a line of
+     text, or nothing for bars without text. The text is cut off with an
+     ellipsis where the bar is too narrow for it and left out where even that
+     would say nothing; a bar that began before the view keeps its text at the
+     view's edge. */
+    label?: (subtask: Subtask) => string;
+    /** The tooltip on a hovered subtask or transport: its order, its times, its
+     parts and its findings. `false` switches it off; a function receives
+     what the pointer rests on and returns content of the application's own. */
+    tooltip?: false | ((target: ScheduleTooltipTarget) => ReactNode);
+    /** A line marking the present across the lanes: `true` follows the clock by
+     the minute, an instant fixes it there. Off by default. */
+    now?: boolean | number;
+    /** Goes to the root element. */
+    className?: string;
+    /** Goes to the root element. */
+    style?: CSSProperties;
+    /** `Lane`, `Transports` and `Subtasks`, in the order they are to stand and
+     be drawn. */
+    children?: ReactNode;
+}
+
+/** What a tooltip is about: the hovered subtask or transport, with what the
+ schedule knows about it. */
+export declare type ScheduleTooltipTarget = {
+    /** A subtask is hovered. */
+    readonly kind: "subtask";
+    /** The hovered subtask. */
+    readonly subtask: Subtask;
+    /** Its task, where the tasks name it. */
+    readonly task: Task | undefined;
+    /** The subtasks it overlaps with on its lane. */
+    readonly overlapping: readonly Subtask[];
+    /** The late transports leaving or reaching it. */
+    readonly lateTransports: readonly LateTransport[];
+} | {
+    /** A transport is hovered. */
+    readonly kind: "transport";
+    /** The hovered transport. */
+    readonly transport: Transport;
+    /** Its task, where the tasks name it. */
+    readonly task: Task | undefined;
+    /** The subtask it leaves. */
+    readonly from: Subtask | undefined;
+    /** The subtask it reaches. */
+    readonly to: Subtask | undefined;
+    /** Its finding, where it is late. */
+    readonly late: LateTransport | undefined;
+};
+
+/** Change the setup on its own. */
+export declare interface SetupIntent {
+    readonly kind: "setup";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new duration of the setup. */
+    readonly setup: number;
+}
+
+export declare function shiftTask(subtasks: readonly Subtask[], task: string, by: number): MoveIntent[];
+
+/** A raster: a step, and where it starts after local midnight. */
+export declare interface SnapRaster {
+    /** The distance between two lines of the raster, in milliseconds. */
+    readonly step: number;
+    /** Where the raster starts after local midnight, in milliseconds: six
+     hours for shifts that change at 06:00. */
+    readonly offset: number;
+}
+
+/** `time` onto the nearest line of the raster in local time - a step alone
+ starts at local midnight. A step of zero or less is no raster: the time
+ stays as it is. */
+export declare function snapTime(time: number, raster: number | SnapRaster): number;
+
+/** Stretch the main time at one or both of its edges. */
+export declare interface StretchIntent {
+    readonly kind: "stretch";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new start of the main time. */
+    readonly from: number;
+    /** The new end of the main time. */
+    readonly to: number;
+}
+
+/** The drawn interval: a main time on one lane, with an optional setup before
+ it and a teardown after it. */
+export declare interface Subtask {
+    /** The caller's identity of the subtask. */
+    readonly id: string;
+    /** The id of the task it belongs to. */
+    readonly task: string;
+    /** The id of the lane it sits on. */
+    readonly lane: string;
+    /** Start of the main time. */
+    readonly from: number;
+    /** End of the main time. */
+    readonly to: number;
+    /** Duration of the setup before the main time; none is zero. */
+    readonly setup?: number;
+    /** Duration of the teardown after the main time; none is zero. */
+    readonly teardown?: number;
+    /** What the subtask is called, where the schedule names it. */
+    readonly name?: string;
+    /** What the bar says besides its colour: `"provisional"`, `"fixed"`,
+     `"muted"`, `"open"`. Several hold at once; `"provisional"` and `"fixed"`
+     contradict, and the later one in the list wins. */
+    readonly appearance?: readonly SubtaskAppearance[];
+    /** The share of the work that is done, from 0 to 1, drawn as a filled part
+     of the bar. Without it nothing is claimed - an empty bar and a bar at
+     zero per cent are two different statements. */
+    readonly progress?: number;
+}
+
+/** The appearances a caller may give a subtask. */
+export declare type SubtaskAppearance = "provisional" | "fixed" | "muted" | "open";
+
+/** The subtask a place intent asks for, under an id the caller chooses. */
+export declare function subtaskFromPlace(intent: PlaceIntent, id: string): Subtask;
+
+/** A layer of subtasks. Several layers draw in the order they are declared. */
+export declare function Subtasks({ data, tasks }: SubtasksProps): null;
+
+export declare interface SubtasksProps {
+    /** The subtasks, as the caller holds them. The schedule never changes one. */
+    data: readonly Subtask[];
+    /** The tasks the subtasks belong to - their identity and their colour. A
+     subtask whose task is not among them is drawn in a muted colour. */
+    tasks: readonly Task[];
+}
+
+/** One whole undertaking. It is never drawn as a thing of its own: it shows as
+ the colour its subtasks share, and in selection, which takes all of it. */
+export declare interface Task {
+    /** The caller's identity of the task. */
+    readonly id: string;
+    /** Any CSS colour - a literal, a token, `light-dark(…)`. The colour means what
+     the caller's domain needs it to mean. */
+    readonly color: string;
+    /** What the task is called, where the schedule names it. */
+    readonly name?: string;
+}
+
+/** Change the teardown on its own. */
+export declare interface TeardownIntent {
+    readonly kind: "teardown";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new duration of the teardown. */
+    readonly teardown: number;
+}
+
+/** A task's move between two of its subtasks: always from an end to a start. */
+export declare interface Transport {
+    /** The caller's identity of the transport. */
+    readonly id: string;
+    /** The id of the subtask it leaves. */
+    readonly from: string;
+    /** The id of the subtask it arrives at. */
+    readonly to: string;
+    /** How long the move takes. */
+    readonly duration: number;
+    /** Where it leaves: at the end of the main time, or after the teardown.
+     Default `"teardown"` - the part leaves once the machine is cleared. */
+    readonly leaves?: "main" | "teardown";
+    /** Where it arrives: at the start of the main time, or before the setup.
+     Default `"setup"` - the part must be there before the machine is set up. */
+    readonly arrives?: "main" | "setup";
+    /** How this one is drawn, where it is not drawn like the rest. It changes
+     the picture and never the finding: whether a transport is late follows
+     from `leaves` and `arrives` alone. */
+    readonly route?: TransportRoute;
+    /** Where on the bars this one's line attaches, where it does not attach like
+     the rest. Also picture only, and not to be confused with the two anchors
+     above: those say what the transport connects, this says where the line
+     touches. */
+    readonly attach?: TransportAttachment;
+    /** Whether this one's ends are marked with a dot, where it is not marked
+     like the rest. Also picture only. */
+    readonly ends?: TransportEnds;
+}
+
+/** Where on its bars a transport's line attaches: the middle of both, or the
+ edge that faces the other stop - which is the shortest line between them.
+
+ Deliberately not called an anchor: a transport already HAS two anchors
+ (`leaves`, `arrives`), and those decide what it connects and therefore
+ whether it is late. This decides where the line touches, and nothing else.
+ The tree has an **Anchor** of its own as well (CONTEXT.md). */
+export declare type TransportAttachment = "centre" | "nearest";
+
+/** Whether a transport's two ends carry a dot. The dot says where the line is
+ anchored, which is worth saying while a plan is being read and is noise in a
+ plan full of short moves - so it is the caller's choice. */
+export declare type TransportEnds = "dot" | "none";
+
+/** How a transport is drawn between its two ends: a curve that leaves and
+ arrives forwards, a straight line, or axis-parallel segments. */
+export declare type TransportRoute = "curve" | "straight" | "orthogonal";
+
+/** A layer of transports. Declared before `Subtasks`, the lines run beneath the
+ bars; after them, above. */
+export declare function Transports({ data }: TransportsProps): null;
+
+export declare interface TransportsProps {
+    /** The transports, as the caller holds them. */
+    data: readonly Transport[];
+}
+
+/** The narrowest and the widest span zoom may reach. */
+export declare interface ZoomLimits {
+    readonly min: number;
+    readonly max: number;
+}
+
+export { }

package/dist/schedule.css

@@ -0,0 +1 @@
+@layer umriss.tokens,umriss.base,umriss.components;@layer umriss.base{._text_18b86_23{font-family:var(--u-font-sans);font-size:var(--u-text-md);line-height:var(--u-leading-normal);color:var(--u-color-text);-webkit-font-smoothing:antialiased;text-rendering:optimizeLegibility}._field_18b86_34{caret-color:var(--u-color-accent)}._scroll_18b86_40{scrollbar-width:thin;scrollbar-color:color-mix(in srgb,var(--u-color-text) 25%,transparent) transparent}._scroll_18b86_40::-webkit-scrollbar{width:10px;height:10px}._scroll_18b86_40::-webkit-scrollbar-thumb{background:color-mix(in srgb,var(--u-color-text) 22%,transparent);border-radius:var(--u-radius-full);border:3px solid transparent;background-clip:content-box}._scroll_18b86_40::-webkit-scrollbar-track{background:transparent}}@layer umriss.components{._ring_18b86_65:focus-visible{outline:none;box-shadow:var(--u-focus-ring)}._field_18b86_34:-webkit-autofill,._field_18b86_34:-webkit-autofill:hover,._field_18b86_34:-webkit-autofill:focus{-webkit-box-shadow:inset 0 0 0 1000px var(--u-color-surface),0 0 0 1px var(--u-edge-color-strong);-webkit-text-fill-color:var(--u-color-text);caret-color:var(--u-color-accent)}}@layer umriss.tokens,umriss.base,umriss.components;@layer umriss.components{._root_ekx9o_4,._root_ekx9o_4:before,._root_ekx9o_4:after{box-sizing:border-box}._corner_ekx9o_18,._corner_ekx9o_18:before,._corner_ekx9o_18:after{box-sizing:border-box}._dayBand_ekx9o_22,._dayBand_ekx9o_22:before,._dayBand_ekx9o_22:after{box-sizing:border-box}._tickBand_ekx9o_23,._tickBand_ekx9o_23:before,._tickBand_ekx9o_23:after{box-sizing:border-box}._day_ekx9o_22,._day_ekx9o_22:before,._day_ekx9o_22:after{box-sizing:border-box}._dayLabel_ekx9o_46,._dayLabel_ekx9o_46:before,._dayLabel_ekx9o_46:after{box-sizing:border-box}._tick_ekx9o_23,._tick_ekx9o_23:before,._tick_ekx9o_23:after{box-sizing:border-box}._tickLabel_ekx9o_64,._tickLabel_ekx9o_64:before,._tickLabel_ekx9o_64:after{box-sizing:border-box}._headers_ekx9o_72,._headers_ekx9o_72:before,._headers_ekx9o_72:after{box-sizing:border-box}._header_ekx9o_72,._header_ekx9o_72:before,._header_ekx9o_72:after{box-sizing:border-box}._headerLabel_ekx9o_90,._headerLabel_ekx9o_90:before,._headerLabel_ekx9o_90:after{box-sizing:border-box}._headerCount_ekx9o_103,._headerCount_ekx9o_103:before,._headerCount_ekx9o_103:after{box-sizing:border-box}._chevron_ekx9o_112,._chevron_ekx9o_112:before,._chevron_ekx9o_112:after{box-sizing:border-box}._plot_ekx9o_160,._plot_ekx9o_160:before,._plot_ekx9o_160:after{box-sizing:border-box}._layer_ekx9o_166,._layer_ekx9o_166:before,._layer_ekx9o_166:after{box-sizing:border-box}._grip_ekx9o_175,._grip_ekx9o_175:before,._grip_ekx9o_175:after{box-sizing:border-box}._ghostLabel_ekx9o_185,._ghostLabel_ekx9o_185:before,._ghostLabel_ekx9o_185:after{box-sizing:border-box}._finding_ekx9o_198,._finding_ekx9o_198:before,._finding_ekx9o_198:after{box-sizing:border-box}._refusal_ekx9o_206,._refusal_ekx9o_206:before,._refusal_ekx9o_206:after{box-sizing:border-box}._tooltip_ekx9o_210,._tooltip_ekx9o_210:before,._tooltip_ekx9o_210:after{box-sizing:border-box}._tooltipHead_ekx9o_228,._tooltipHead_ekx9o_228:before,._tooltipHead_ekx9o_228:after{box-sizing:border-box}._tooltipTimes_ekx9o_233,._tooltipTimes_ekx9o_233:before,._tooltipTimes_ekx9o_233:after{box-sizing:border-box}._now_ekx9o_242,._now_ekx9o_242:before,._now_ekx9o_242:after{box-sizing:border-box}._barLabel_ekx9o_256,._barLabel_ekx9o_256:before,._barLabel_ekx9o_256:after{box-sizing:border-box}._barLabelText_ekx9o_269,._barLabelText_ekx9o_269:before,._barLabelText_ekx9o_269:after{box-sizing:border-box}._root_ekx9o_4{display:grid;grid-template-rows:28px minmax(0,1fr) 28px;width:100%;font-size:var(--u-text-sm);background:var(--u-color-surface);box-shadow:var(--u-edge);border-radius:var(--u-radius-md);corner-shape:squircle;overflow:hidden;font-variant-numeric:tabular-nums;-webkit-user-select:none;user-select:none}._corner_ekx9o_18{background:var(--u-color-surface)}._dayBand_ekx9o_22,._tickBand_ekx9o_23{position:relative;overflow:hidden;color:var(--u-color-text-muted);font-size:var(--u-text-xs)}._dayBand_ekx9o_22{border-bottom:1px solid var(--u-hairline-strong)}._tickBand_ekx9o_23{border-top:1px solid var(--u-hairline-strong)}._day_ekx9o_22{position:absolute;top:0;bottom:0;border-left:1px solid var(--u-hairline-strong);overflow:hidden}._dayLabel_ekx9o_46{position:absolute;left:var(--u-space-2);top:50%;transform:translateY(-50%);white-space:nowrap;color:var(--u-color-text);font-weight:var(--u-weight-medium)}._tick_ekx9o_23{position:absolute;top:0;bottom:0;width:1px;background:var(--u-hairline)}._tickLabel_ekx9o_64{position:absolute;top:50%;left:0;transform:translate(-50%,-50%);white-space:nowrap}._headers_ekx9o_72{position:relative;overflow:hidden;border-right:1px solid var(--u-hairline-strong)}._header_ekx9o_72{display:flex;align-items:center;gap:var(--u-space-2);padding-right:var(--u-space-3);border-bottom:1px solid var(--u-hairline);overflow:hidden;white-space:nowrap}._headerLabel_ekx9o_90{min-width:0;overflow:hidden;text-overflow:ellipsis}._header_ekx9o_72[data-row=groupHead],._header_ekx9o_72[data-row=miniature]{font-weight:var(--u-weight-medium)}._headerCount_ekx9o_103{flex:none;color:var(--u-color-text-muted);font-size:var(--u-text-xs);font-variant-numeric:tabular-nums}._chevron_ekx9o_112{flex:none;display:inline-flex;align-items:center;justify-content:center;width:16px;height:16px;padding:0;border:none;border-radius:var(--u-radius-xs);corner-shape:squircle;background:transparent;color:var(--u-color-text-secondary);cursor:pointer}._chevron_ekx9o_112:hover{color:var(--u-color-text)}._chevron_ekx9o_112:focus-visible{outline:none;box-shadow:var(--u-focus-ring);color:var(--u-color-text)}._chevron_ekx9o_112 svg{box-sizing:border-box}._chevron_ekx9o_112 svg{transition:transform var(--u-duration-fast) var(--u-ease-standard)}._chevron_ekx9o_112 svg[data-open]{box-sizing:border-box}._chevron_ekx9o_112 svg[data-open]{transform:rotate(90deg)}@media(prefers-reduced-motion:reduce){._chevron_ekx9o_112 svg{transition:none}}._header_ekx9o_72[data-refused]{color:var(--u-color-text-muted)}._plot_ekx9o_160{position:relative;overflow:hidden;touch-action:none}._layer_ekx9o_166{position:absolute;top:0;right:0;bottom:0;left:0;width:100%;height:100%;display:block;pointer-events:none}._grip_ekx9o_175{position:absolute;width:9px;margin-left:-4px;border-radius:var(--u-radius-xs);corner-shape:squircle;background:var(--u-color-surface);box-shadow:inset 0 0 0 1.5px var(--u-color-text);cursor:ew-resize}._ghostLabel_ekx9o_185{position:absolute;display:inline-flex;gap:var(--u-space-2);padding:1px var(--u-space-2);border-radius:var(--u-radius-sm);corner-shape:squircle;background:var(--u-color-text);color:var(--u-color-surface);font-size:var(--u-text-xs);white-space:nowrap;pointer-events:none}._finding_ekx9o_198{font-weight:var(--u-weight-semibold);color:var(--u-color-danger-subtle)}._refusal_ekx9o_206{font-weight:var(--u-weight-semibold)}._tooltip_ekx9o_210{position:absolute;z-index:1;display:flex;flex-direction:column;gap:1px;max-width:260px;padding:var(--u-space-2) var(--u-space-3);border-radius:var(--u-radius-sm);corner-shape:squircle;background:var(--u-color-surface);box-shadow:var(--u-shadow-overlay);color:var(--u-color-text-secondary);font-size:var(--u-text-xs);line-height:var(--u-leading-tight);pointer-events:none;white-space:nowrap}._tooltipHead_ekx9o_228{color:var(--u-color-text);font-weight:var(--u-weight-semibold)}._tooltipTimes_ekx9o_233{color:var(--u-color-text)}._tooltip_ekx9o_210 ._finding_ekx9o_198{color:var(--u-color-danger)}._now_ekx9o_242{position:absolute;top:0;width:0;height:0;margin-left:-4px;border-left:5px solid transparent;border-right:5px solid transparent;border-top:6px solid var(--u-color-accent)}._barLabel_ekx9o_256{position:absolute;display:flex;align-items:center;padding:0 var(--u-space-1);overflow:hidden;font-size:var(--u-text-xs);line-height:var(--u-leading-tight);pointer-events:none}._barLabelText_ekx9o_269{min-width:0;overflow:hidden;white-space:nowrap;text-overflow:ellipsis}._barLabel_ekx9o_256[data-on=dark]{color:var(--u-color-on-accent)}._barLabel_ekx9o_256[data-on=light]{color:var(--u-color-text)}}