@umriss-ui/schedule 0.2.0 → 0.3.0

package/dist/index.d.ts

@@ -8,37 +8,149 @@ import { RefAttributes } from 'react';
  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 dependency has to have arrived at its subtask, by its anchor. */
+export declare function arrival(dependency: Dependency, to: Subtask): number;
+
+/** Time a lane is not available: leave, maintenance, a holiday. Work does
+ not belong in it - a subtask that covers some of it is a finding
+ (`inBlockedTime`), and a drag does not put one there.
+
+ A list of its own, keyed by lane like a subtask, and not a prop of `Lane`:
+ a lane is structure (ADR-0025) and blocked time is data (ADR-0023) - it
+ comes from the caller's leave table or maintenance plan as one array, and
+ the pure `findings` reads exactly the array `<BlockedTimes>` draws. */
+export declare interface BlockedTime {
+    /** The caller's identity of the interval - what a finding names. */
+    readonly id: string;
+    /** The id of the lane it blocks. */
+    readonly lane: string;
+    /** Where it begins. */
+    readonly from: number;
+    /** Where it ends. */
+    readonly to: number;
+    /** Why the lane is blocked - "Leave", "Maintenance" -, where the schedule
+     names it. */
+    readonly label?: string;
+}
+
+/** A layer of blocked time. Wherever it is declared, it is drawn behind every
+ subtask and dependency: it is a property of the lane, not something on it. */
+export declare function BlockedTimes({ data }: BlockedTimesProps): null;
 
-/** When a transport leaves its subtask, by its anchor. */
-export declare function departure(transport: Transport, from: Subtask): number;
+export declare interface BlockedTimesProps {
+    /** The blocked time of the lanes - leave, maintenance, unavailability -, as
+     the caller holds it: one list, each interval naming its lane. */
+    data: readonly BlockedTime[];
+}
+
+/** When a dependency leaves its subtask, by its anchor. */
+export declare function departure(dependency: Dependency, from: Subtask): number;
+
+/** A layer of dependencies. Declared before `Subtasks`, the lines run beneath the
+ bars; after them, above. */
+export declare function Dependencies({ data }: DependenciesProps): null;
+
+export declare interface DependenciesProps {
+    /** The dependencies, as the caller holds them. */
+    data: readonly Dependency[];
+}
 
-/** Both kinds of finding over the same data. */
+/** Two subtasks of one task in order: the later one may not begin before the
+ earlier one ends plus a lag. Always from an end to a start. */
+export declare interface Dependency {
+    /** The caller's identity of the dependency. */
+    readonly id: string;
+    /** The id of the subtask it leaves. */
+    readonly from: string;
+    /** The id of the subtask it arrives at. */
+    readonly to: string;
+    /** The least time between the two anchors; zero where the successor may
+     begin as soon as the predecessor ends. */
+    readonly lag: number;
+    /** Where it leaves: at the end of the main time, or after the lead-out.
+     Default `"leadOut"` - the predecessor counts as ended once its lead-out is. */
+    readonly leaves?: "main" | "leadOut";
+    /** Where it arrives: at the start of the main time, or before the lead-in.
+     Default `"leadIn"` - the lag must have run out before the successor's
+     lead-in begins. */
+    readonly arrives?: "main" | "leadIn";
+    /** How this one is drawn, where it is not drawn like the rest. It changes
+     the picture and never the finding: whether a dependency is violated follows
+     from `leaves` and `arrives` alone. */
+    readonly route?: DependencyRoute;
+    /** 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 dependency connects, this says where the line
+     touches. */
+    readonly attach?: DependencyAttachment;
+    /** Whether this one's ends are marked with a dot, where it is not marked
+     like the rest. Also picture only. */
+    readonly ends?: DependencyEnds;
+}
+
+/** Where on its bars a dependency'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 dependency already HAS two anchors
+ (`leaves`, `arrives`), and those decide what it connects and therefore
+ whether it is violated. This decides where the line touches, and nothing else.
+ The tree has an **Anchor** of its own as well (CONTEXT.md). */
+export declare type DependencyAttachment = "centre" | "nearest";
+
+/** Whether a dependency'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 DependencyEnds = "dot" | "none";
+
+/** How a dependency is drawn between its two ends: a curve that leaves and
+ arrives forwards, a straight line, or axis-parallel segments. */
+export declare type DependencyRoute = "curve" | "straight" | "orthogonal";
+
+/** Every kind of finding over the same data. */
 export declare interface Findings {
     readonly overlaps: readonly Overlap[];
-    readonly lateTransports: readonly LateTransport[];
+    readonly violatedDependencies: readonly ViolatedDependency[];
+    readonly inBlockedTime: readonly InBlockedTime[];
 }
 
-/** Overlaps and late transports at once. */
-export declare function findings(subtasks: readonly Subtask[], transports: readonly Transport[]): Findings;
+/** Every finding at once. Without blocked time there is none in it. */
+export declare function findings(subtasks: readonly Subtask[], dependencies: readonly Dependency[], blocked?: readonly BlockedTime[]): Findings;
+
+/** A subtask covering time its lane is blocked. */
+export declare interface InBlockedTime {
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The id of the blocked time it covers. */
+    readonly blocked: string;
+    /** The lane both are on. */
+    readonly lane: string;
+    /** Where the covering begins. */
+    readonly from: number;
+    /** Where it ends. */
+    readonly to: number;
+}
+
+/** Every subtask that covers blocked time on its lane, lead-in and lead-out
+ included - once per blocked interval it covers, in the order of the
+ subtasks. Touching at a shared edge is not covering. */
+export declare function inBlockedTime(subtasks: readonly Subtask[], blocked: readonly BlockedTime[]): InBlockedTime[];
 
 /** 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;
+export declare type Intent = MoveIntent | StretchIntent | LeadInIntent | LeadOutIntent | 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
+/** One lane: a person, a vehicle, a room. 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
+ group and a group reads in JSX as it reads in the organisation. 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**. */
@@ -49,7 +161,7 @@ export declare interface LaneGroupProps {
      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.
+    /** What the group's header says - the team, the depot, the region.
      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. */
@@ -68,27 +180,28 @@ export declare interface LaneIntent {
 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
+    /** What the lane header says - the person, vehicle or room. 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;
+/** Change the lead-in on its own. */
+export declare interface LeadInIntent {
+    readonly kind: "leadIn";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new duration of the lead-in. */
+    readonly leadIn: 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[];
+/** Change the lead-out on its own. */
+export declare interface LeadOutIntent {
+    readonly kind: "leadOut";
+    /** The id of the subtask. */
+    readonly subtask: string;
+    /** The new duration of the lead-out. */
+    readonly leadOut: number;
+}
 
 /** Move the subtask in time: the main time keeps its length. */
 export declare interface MoveIntent {
@@ -101,7 +214,7 @@ export declare interface MoveIntent {
     readonly to: number;
 }
 
-/** The interval a subtask occupies on its lane: setup and teardown included. */
+/** The interval a subtask occupies on its lane: lead-in and lead-out included. */
 export declare function occupied(subtask: Subtask): {
     from: number;
     to: number;
@@ -111,7 +224,7 @@ export declare function occupied(subtask: Subtask): {
 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
+    /** The subtask that starts earlier (lead-in included); on a tie, the one that
      stands first in the data. */
     readonly first: string;
     /** The other one. */
@@ -143,10 +256,10 @@ export declare interface PlaceIntent {
     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;
+    /** The lead-in it was declared with. */
+    readonly leadIn?: number;
+    /** The lead-out it was declared with. */
+    readonly leadOut?: number;
 }
 
 /** What the application says it is dragging in, while it drags it
@@ -159,10 +272,10 @@ export declare interface PlacingItem {
     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;
+    /** The lead-in it brings. */
+    readonly leadIn?: number;
+    /** The lead-out it brings. */
+    readonly leadOut?: number;
 }
 
 export declare function resolveAppearance(appearance: readonly SubtaskAppearance[] | undefined): ResolvedAppearance;
@@ -183,18 +296,18 @@ export declare interface ResolvedAppearance {
      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. */
+     opaque and at full height. Another team'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
+/** The moves that push every successor whose dependency 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 function ripple(subtasks: readonly Subtask[], dependencies: readonly Dependency[], intent: Intent): MoveIntent[];
 
 export declare const Schedule: ForwardRefExoticComponent<ScheduleProps & RefAttributes<ScheduleHandle>>;
 
@@ -220,10 +333,10 @@ export declare interface ScheduleHandle {
 export declare type ScheduleHit = {
     readonly kind: "subtask";
     readonly subtask: Subtask;
-    readonly part: "setup" | "main" | "teardown";
+    readonly part: "leadIn" | "main" | "leadOut";
 } | {
-    readonly kind: "transport";
-    readonly transport: Transport;
+    readonly kind: "dependency";
+    readonly dependency: Dependency;
 } | {
     readonly kind: "lane";
     readonly lane: string;
@@ -261,7 +374,7 @@ export declare interface ScheduleProps {
     /** Width of the lane headers in pixels - at most 40 % of the schedule, so
      that on a phone the plot keeps the larger part. */
     headerWidth?: number;
-    /** An operating calendar: the intervals in which time counts. Nights and
+    /** A working 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.
@@ -298,7 +411,7 @@ export declare interface ScheduleProps {
      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
+     subtask that was clicked - null where the click was on a dependency or on
      nothing. It is called again when another subtask of the same task is
      clicked. */
     onSelectedTaskChange?: (task: string | null, subtask: string | null) => void;
@@ -321,34 +434,34 @@ export declare interface ScheduleProps {
      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
+     key, task, the length of its main time, its lead-in and lead-out. 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
+    /** How the dependencies are drawn: a `"curve"` that leaves and arrives
+     forwards, a `"straight"` line, or `"orthogonal"` segments. A dependency may
      say otherwise for itself. */
-    route?: TransportRoute;
-    /** Where a transport's ends sit on their bars: the `"centre"` of both, or the
+    route?: DependencyRoute;
+    /** Where a dependency'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.
+     one lane both mean the middle. A dependency may say otherwise for itself.
 
-     It changes the picture and never a finding: whether a transport is late
+     It changes the picture and never a finding: whether a dependency is violated
      follows from its `leaves` and `arrives` alone. */
-    attach?: TransportAttachment;
-    /** Whether a transport's two ends carry a dot (`"dot"`, the default) or the
+    attach?: DependencyAttachment;
+    /** Whether a dependency'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;
+     A dependency may say otherwise for itself. */
+    ends?: DependencyEnds;
     /** 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
+    /** The tooltip on a hovered subtask or dependency: 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);
@@ -359,12 +472,12 @@ export declare interface ScheduleProps {
     className?: string;
     /** Goes to the root element. */
     style?: CSSProperties;
-    /** `Lane`, `Transports` and `Subtasks`, in the order they are to stand and
+    /** `Lane`, `Dependencies` 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
+/** What a tooltip is about: the hovered subtask or dependency, with what the
  schedule knows about it. */
 export declare type ScheduleTooltipTarget = {
     /** A subtask is hovered. */
@@ -375,32 +488,25 @@ export declare type ScheduleTooltipTarget = {
     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[];
+    /** The violated dependencies leaving or reaching it. */
+    readonly violatedDependencies: readonly ViolatedDependency[];
+    /** The blocked time it covers on its lane. */
+    readonly blocked: readonly BlockedTime[];
 } | {
-    /** A transport is hovered. */
-    readonly kind: "transport";
-    /** The hovered transport. */
-    readonly transport: Transport;
+    /** A dependency is hovered. */
+    readonly kind: "dependency";
+    /** The hovered dependency. */
+    readonly dependency: Dependency;
     /** 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;
+    /** Its finding, where it is violated. */
+    readonly violated: ViolatedDependency | 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. */
@@ -408,7 +514,7 @@ 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. */
+     hours for handovers at 06:00, 14:00 and 22:00. */
     readonly offset: number;
 }
 
@@ -428,8 +534,8 @@ export declare interface StretchIntent {
     readonly to: number;
 }
 
-/** The drawn interval: a main time on one lane, with an optional setup before
- it and a teardown after it. */
+/** The drawn interval: a main time on one lane, with an optional lead-in before
+ it and a lead-out after it. */
 export declare interface Subtask {
     /** The caller's identity of the subtask. */
     readonly id: string;
@@ -441,10 +547,10 @@ export declare interface Subtask {
     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;
+    /** Duration of the lead-in before the main time; none is zero. */
+    readonly leadIn?: number;
+    /** Duration of the lead-out after the main time; none is zero. */
+    readonly leadOut?: number;
     /** What the subtask is called, where the schedule names it. */
     readonly name?: string;
     /** What the bar says besides its colour: `"provisional"`, `"fixed"`,
@@ -486,70 +592,21 @@ export declare interface Task {
     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;
+/** Every dependency whose successor is to be reached before the predecessor's
+ departure plus the dependency's lag. A dependency naming a subtask that
+ is not in the data is passed over: there is nothing to judge. */
+export declare function violatedDependencies(subtasks: readonly Subtask[], dependencies: readonly Dependency[]): ViolatedDependency[];
 
-export declare interface TransportsProps {
-    /** The transports, as the caller holds them. */
-    data: readonly Transport[];
+/** A dependency whose lag does not fit between its anchors. */
+export declare interface ViolatedDependency {
+    /** The id of the dependency. */
+    readonly dependency: 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 lag, minus arrival. */
+    readonly shortBy: number;
 }
 
 /** The narrowest and the widest span zoom may reach. */