react-native-roster 0.2.0 → 0.4.0

package/src/components/roster/use-roster.ts

@@ -2,7 +2,7 @@ import { useRef, useState } from 'react';
 import type { ScrollView } from 'react-native';
 import { makeMutable, useAnimatedStyle } from 'react-native-reanimated';
 import type { Lane, LaneGeometry, Rect, Window } from '../../core';
-import { byLabel, coverageFor, flagFor, layoutLane, timeAtX, windowFor } from '../../core';
+import { byLabel, coverageFor, flagFor, layoutLane, timeAtX, windowFor, xAtTime } from '../../core';
 import type { RosterInput, RosterModel, RosterProjection } from './roster.types';
 import { type SelectedInterval, useRosterPress } from './use-roster-press';
 import { ticksFor } from './utils/ticks';
@@ -11,6 +11,7 @@ export function useRoster(input: RosterInput): RosterModel {
   const {
     lanes,
     windowSpec,
+    now = null,
     minuteStep = 60,
     sortLanes = byLabel,
     rowHeight = 48,
@@ -44,6 +45,10 @@ export function useRoster(input: RosterInput): RosterModel {
     rowHeight,
     pxPerMinute: Math.max(pxPerMinute, duration === 0 ? 0 : viewport.width / duration),
   };
+  const nowLine =
+    now !== null && now >= window.start && now < window.end
+      ? { x: xAtTime(projection, window, now), now }
+      : null;
   const contentWidth = duration * projection.pxPerMinute;
   const coverage = new Map(lanes.map((lane) => [lane.id, coverageFor(lane, window)]));
   const orderedLanes = [...lanes].sort((a, b) => sortLanes(a, b, coverage));
@@ -78,6 +83,8 @@ export function useRoster(input: RosterInput): RosterModel {
     press,
     status: lanes.length === 0 ? 'empty' : 'ready',
     ticks: ticksFor(window, windowSpec, projection, minuteStep),
+    now,
+    nowLine,
     contentWidth,
     viewport,
     navigate: (next) => onNavigate?.(next),

package/src/core/README.md

@@ -6,6 +6,9 @@ no React Native, no dependencies.
 - Public subpath: `react-native-roster/core`; the root entry re-exports it
 - Authoritative types: `types.ts` (`Lane`, `Layer`, `Interval`, `Gap`,
   `Source`, `Window`, `Projection`, `Rect`, `Coverage`, `LaneGeometry`)
+- Interval helpers: `extentOf(segments: readonly Window[]): Window | null`,
+  `intersectionOf(spans: readonly Window[]): Window | null`, and
+  `unionOf(spans: readonly Window[]): Window[]`
 - Barrel: `index.ts` only
 
 | File | Role |
@@ -14,14 +17,24 @@ no React Native, no dependencies.
 | `layout.ts` | rect geometry for one lane in either projection |
 | `coverage.ts` | covered and removed minutes per lane |
 | `source.ts` | `hasSource(sources, source)` matches kind and id, ignoring labels |
-| `spans.ts` | the provenance sweep: exact sources per merged span |
+| `spans.ts` | `extentOf`, `intersectionOf`, `unionOf`, and the provenance sweep with exact sources per merged span |
 | `columns.ts` | day columns, transitions, and skipped dates for the columns projection |
 | `zone.ts` | Intl-only timezone math (offsets, first instants, transitions) |
-| `scale.ts`, `snap.ts` | pixel and time conversion, pointer snapping |
+| `scale.ts`, `snap.ts` | pixel and time conversion (`xAtTime`, `timeAtX`, `timeAtY`), pointer snapping |
 | `hit-test.ts` | the geometry walk both hooks use to resolve a press |
 | `order.ts`, `flag.ts` | lane comparators and lane flags |
 | `cache.ts`, `hash.ts` | layout and coverage caches keyed by lane content |
 
+All interval helpers reuse the bare `{ start, end }` `Window` type with
+end-exclusive epoch millisecond bounds. `extentOf` bridges disjoint segments;
+`intersectionOf` returns only their shared span. Both return `null` for empty
+input; an empty intersection, including touching bounds, also returns `null`.
+`unionOf` merges overlapping or touching windows, sorts by start, and keeps
+disjoint windows separate. It returns `[]` for empty input and new window objects.
+Every input must have finite bounds and `end > start`; otherwise the helpers throw `RangeError`.
+Inputs may be unsorted, overlapping, nested, or duplicated; inputs are not mutated.
+The existing `Span` type names axis choices only.
+
 Reference: [design](../../docs/design.md), [timezones](../../docs/timezones.md),
 [caches](../../docs/caches.md). Tests: `test/core`.
 

package/src/core/index.ts

@@ -13,8 +13,9 @@ export { flagFor } from './flag';
 export { layoutLane } from './layout';
 export type { LaneComparator } from './order';
 export { byCoverage, byLabel } from './order';
-export { snapToStep, timeAtX, timeAtY } from './snap';
+export { snapToStep, timeAtX, timeAtY, xAtTime } from './snap';
 export { hasSource } from './source';
+export { extentOf, intersectionOf, unionOf } from './spans';
 export type {
   Coverage,
   DayColumn,

package/src/core/layout.ts

@@ -3,6 +3,7 @@ import { coverageFor } from './coverage';
 import { flagFor } from './flag';
 import { laneKey, projectionKey } from './hash';
 import { type ScalePiece, scalePieces } from './scale';
+import { xAtTime } from './snap';
 import { sourceSpans } from './spans';
 import type { Interval, Lane, LaneGeometry, Layer, Projection, Rect, Window } from './types';
 
@@ -60,7 +61,7 @@ function project(
   if (projection.orientation === 'horizontal') {
     for (const span of spans) {
       rects.push({
-        x: ((span.start - window.start) / 60_000) * projection.pxPerMinute,
+        x: xAtTime(projection, window, span.start),
         y: inset,
         width: ((span.end - span.start) / 60_000) * projection.pxPerMinute,
         height: Math.max(0, projection.rowHeight - 2 * inset),

package/src/core/snap.ts

@@ -50,3 +50,12 @@ export function timeAtX(
 ): number {
   return window.start + (x * 60_000) / projection.pxPerMinute;
 }
+
+/** Horizontal position at true elapsed length; the window supplies the projection's origin. */
+export function xAtTime(
+  projection: Extract<Projection, { orientation: 'horizontal' }>,
+  window: Window,
+  time: number,
+): number {
+  return ((time - window.start) / 60_000) * projection.pxPerMinute;
+}

package/src/core/spans.ts

@@ -1,5 +1,6 @@
-// Sweep boundaries once; reference counts preserve provenance through nested
-// intervals and equal-time ends/starts. Labels never affect source identity.
+// Provenance sweep logic and the extentOf, intersectionOf, and unionOf interval helpers.
+// The sweep uses reference counts to preserve provenance through nested intervals
+// and equal-time ends/starts. Labels never affect source identity.
 import type { Interval, Source, Window } from './types';
 
 type Boundary = { at: number; delta: number; sources: Source[] };
@@ -56,3 +57,66 @@ export function sourceSpans(intervals: Interval[], window: Window): Interval[] {
   }
   return spans;
 }
+
+/**
+ * Earliest start through latest end in epoch milliseconds, end-exclusive; empty input returns null.
+ * Throws RangeError for non-finite bounds or end <= start.
+ * Inputs may be unsorted, overlapping, nested, or duplicated; inputs are not mutated.
+ */
+export function extentOf(segments: readonly Window[]): Window | null {
+  let start = Infinity;
+  let end = -Infinity;
+  for (const segment of segments) {
+    validateSpan(segment);
+    start = Math.min(start, segment.start);
+    end = Math.max(end, segment.end);
+  }
+  return start < end ? { start, end } : null;
+}
+
+/**
+ * Shared epoch milliseconds, end-exclusive; empty input or an empty intersection returns null.
+ * Throws RangeError for non-finite bounds or end <= start.
+ * Inputs may be unsorted, overlapping, nested, or duplicated; inputs are not mutated.
+ */
+export function intersectionOf(spans: readonly Window[]): Window | null {
+  if (spans.length === 0) return null;
+  let start = -Infinity;
+  let end = Infinity;
+  for (const span of spans) {
+    validateSpan(span);
+    start = Math.max(start, span.start);
+    end = Math.min(end, span.end);
+  }
+  return start < end ? { start, end } : null;
+}
+
+/**
+ * Merged end-exclusive epoch windows sorted by start; empty input returns an empty array.
+ * Overlapping or touching spans merge; disjoint spans remain separate.
+ * Throws RangeError for non-finite bounds or end <= start.
+ * Returns new objects without mutating inputs.
+ */
+export function unionOf(spans: readonly Window[]): Window[] {
+  const sorted = spans.map((span) => {
+    validateSpan(span);
+    return { start: span.start, end: span.end };
+  });
+  sorted.sort((a, b) => a.start - b.start);
+  const merged: Window[] = [];
+  for (const span of sorted) {
+    const last = merged.at(-1);
+    if (last && span.start <= last.end) {
+      last.end = Math.max(last.end, span.end);
+    } else {
+      merged.push(span);
+    }
+  }
+  return merged;
+}
+
+function validateSpan(span: Window): void {
+  if (!Number.isFinite(span.start) || !Number.isFinite(span.end) || span.end <= span.start) {
+    throw new RangeError('Span bounds must be finite with end greater than start');
+  }
+}

package/src/index.ts

@@ -13,6 +13,7 @@ export { RosterHeader } from './components/roster/parts/header';
 export { RosterHeaderCell } from './components/roster/parts/header-cell';
 export { RosterLaneLabelColumn } from './components/roster/parts/lane-label-column';
 export { RosterLaneList } from './components/roster/parts/lane-list';
+export { RosterNowLine } from './components/roster/parts/now-line';
 export type {
   BodyInput,
   GridInput,
@@ -21,8 +22,10 @@ export type {
   IntervalDetailInput,
   LabelColumnInput,
   LaneLabelInput,
+  LaneListInput,
   RosterInput,
   RosterModel,
+  RosterNowLineInput,
   RosterProjection,
   RosterProps,
   RosterScroll,