@motionstudies/core 0.1.0-alpha.3 → 0.1.0-alpha.31

package/domain/route-field.js

@@ -0,0 +1,47 @@
+/** Quiet at the baseline, growing as the ratio falls; a bin below `ring` earns a marker. Mock rule of 18 September 2026. */
+export const PEAK_SPEED_EMPHASIS = { baseline: 1, floor: 0.4, ring: 0.6, glowFrom: 0.15 };
+export function routeFieldValue(bin, minimumSupport) {
+    if (!bin || bin.value === null || !Number.isFinite(bin.value) || bin.value < 0)
+        return null;
+    return Number.isFinite(bin.support) && bin.support >= minimumSupport ? bin.value : null;
+}
+/** Null for an unsupported bin; draw it dashed, not as fine. */
+export function routeFieldEmphasis(value, rule = PEAK_SPEED_EMPHASIS) {
+    if (value === null || !Number.isFinite(value))
+        return null;
+    const span = rule.baseline - rule.floor;
+    const slow = span > 0 ? Math.min(1, Math.max(0, (rule.baseline - value) / span)) : 0;
+    return { width: 1 + 1.6 * slow, glow: slow > rule.glowFrom ? slow : 0, ring: value < rule.ring };
+}
+const EARTH_METRES_PER_DEGREE = 111_320;
+/** Cumulative metres along a longitude/latitude path on a local equirectangular plane; enough for bins of tens of metres. */
+export function pathChainage(path) {
+    const out = [0];
+    if (path.length === 0)
+        return [];
+    for (let i = 1; i < path.length; i++) {
+        const [lon0, lat0] = path[i - 1], [lon1, lat1] = path[i];
+        const scale = Math.cos(((lat0 + lat1) / 2) * Math.PI / 180);
+        out.push(out[i - 1] + Math.hypot((lon1 - lon0) * EARTH_METRES_PER_DEGREE * scale, (lat1 - lat0) * EARTH_METRES_PER_DEGREE));
+    }
+    return out;
+}
+/** Point at `metres` along the path; clamped to its ends. Returns null for an empty path. */
+export function pointAlongPath(path, chainage, metres) {
+    if (path.length === 0 || chainage.length !== path.length)
+        return null;
+    if (path.length === 1 || metres <= 0)
+        return path[0];
+    const end = chainage[chainage.length - 1];
+    if (metres >= end)
+        return path[path.length - 1];
+    let hi = 1;
+    while (chainage[hi] < metres)
+        hi++;
+    const lo = hi - 1, span = chainage[hi] - chainage[lo], f = span > 0 ? (metres - chainage[lo]) / span : 0;
+    return [path[lo][0] + (path[hi][0] - path[lo][0]) * f, path[lo][1] + (path[hi][1] - path[lo][1]) * f];
+}
+/** Bins whose extent overlaps [from,to) metres, in path order. */
+export function routeFieldBinsBetween(field, from, to) {
+    return field.bins.filter(bin => bin.to > from && bin.from < to);
+}

package/domain/station-calls.d.ts

@@ -0,0 +1,48 @@
+import type { NetworkSnapshot, NetworkTrain } from './network.ts';
+export type StationCallDirection = 'arrival' | 'departure';
+export interface StationCall {
+    readonly id: string;
+    readonly train: NetworkTrain;
+    /** Call occurrence within this train, not a global station index. */
+    readonly index: number;
+    readonly arrival: number;
+    readonly departure: number;
+    readonly origin: string;
+    readonly destination: string;
+    readonly allowsArrival: boolean;
+    readonly allowsDeparture: boolean;
+    readonly movementAvailable?: boolean;
+    readonly source?: string;
+    readonly windowStart?: number;
+    readonly windowEnd?: number;
+}
+export interface StationCallSelection {
+    readonly name: string;
+    /** When supplied, source IDs are authoritative; never fall back to a name match. */
+    readonly stopIds?: readonly string[];
+}
+export interface StationCallPolicy {
+    readonly includeTrain?: (train: NetworkTrain) => boolean;
+    readonly allows?: (train: NetworkTrain, callIndex: number, direction: StationCallDirection) => boolean;
+    readonly origin?: (train: NetworkTrain, snapshot: NetworkSnapshot) => string | undefined;
+    readonly destination?: (train: NetworkTrain, snapshot: NetworkSnapshot) => string | undefined;
+}
+/** Retain repeated visits and source-local indexes; passenger restrictions belong to the adapter. */
+export declare function stationCalls(snapshot: NetworkSnapshot, selection: StationCallSelection, policy?: StationCallPolicy): readonly StationCall[];
+export interface StationCallSource {
+    readonly id: string;
+    readonly selection: StationCallSelection;
+    readonly snapshot?: NetworkSnapshot;
+    readonly movements?: NetworkSnapshot;
+    readonly windowStart: number;
+    readonly windowEnd: number;
+    readonly policy?: StationCallPolicy;
+    readonly loading?: boolean;
+    readonly error?: boolean;
+}
+export type StationSourceStatus = 'loading' | 'error' | 'unavailable' | 'date-mismatch' | 'partial' | 'ready';
+export declare function stationSourceStatus(source: StationCallSource, serviceDate: string, requestedStart: number, requestedEnd: number): StationSourceStatus;
+/** Sources remain independently dated and retryable. Equal names/times never merge services. */
+export declare function combinedStationCalls(serviceDate: string, sources: readonly StationCallSource[]): readonly StationCall[];
+/** Clip to both requested and source windows. Never wrap to an unacquired day. */
+export declare function upcomingStationCalls(calls: readonly StationCall[], direction: StationCallDirection, time: number, windowStart: number, windowEnd: number, route?: string, maxRows?: number): readonly StationCall[];

package/domain/station-calls.js

@@ -0,0 +1,73 @@
+/** Retain repeated visits and source-local indexes; passenger restrictions belong to the adapter. */
+export function stationCalls(snapshot, selection, policy = {}) {
+    const stops = new Set(snapshot.stops.flatMap((stop, index) => (selection.stopIds ? Boolean(stop[4] && selection.stopIds.includes(stop[4])) : stop[2] === selection.name) ? [index] : []));
+    const calls = [], ids = new Map();
+    for (const train of snapshot.trains) {
+        if (policy.includeTrain && !policy.includeTrain(train))
+            continue;
+        const prior = ids.get(train.id);
+        if (prior) {
+            if (prior === train || JSON.stringify(prior) === JSON.stringify(train))
+                continue;
+            throw new Error('Ambiguous duplicate journey identity in station source');
+        }
+        ids.set(train.id, train);
+        train.stops.forEach(([stop, arrival, departure], index) => {
+            if (!stops.has(stop) || !Number.isFinite(arrival) || !Number.isFinite(departure) || departure < arrival)
+                return;
+            const allowsArrival = index > 0 && (policy.allows?.(train, index, 'arrival') ?? true);
+            const allowsDeparture = index < train.stops.length - 1 && (policy.allows?.(train, index, 'departure') ?? true);
+            if (!allowsArrival && !allowsDeparture)
+                return;
+            calls.push({ id: `${train.id}:call:${index}`, train, index, arrival, departure,
+                origin: policy.origin?.(train, snapshot) ?? snapshot.stops[train.stops[0][0]]?.[2] ?? '',
+                destination: policy.destination?.(train, snapshot) ?? (train.headsign || snapshot.stops[train.stops.at(-1)[0]]?.[2] || ''),
+                allowsArrival, allowsDeparture, });
+        });
+    }
+    return calls;
+}
+export function stationSourceStatus(source, serviceDate, requestedStart, requestedEnd) {
+    if (source.error)
+        return 'error';
+    if (source.loading)
+        return 'loading';
+    if (!source.snapshot || ![source.windowStart, source.windowEnd, requestedStart, requestedEnd].every(Number.isFinite) ||
+        source.windowEnd <= source.windowStart || requestedEnd < requestedStart)
+        return 'unavailable';
+    if (source.snapshot.metadata.serviceDate !== serviceDate)
+        return 'date-mismatch';
+    return source.windowStart > requestedStart || source.windowEnd < requestedEnd ? 'partial' : 'ready';
+}
+/** Sources remain independently dated and retryable. Equal names/times never merge services. */
+export function combinedStationCalls(serviceDate, sources) {
+    const result = [], ids = new Set();
+    for (const source of sources) {
+        if (!source.id || ids.has(source.id))
+            throw new Error('Station sources require distinct identities');
+        ids.add(source.id);
+        if (!source.snapshot || source.error || source.loading || source.snapshot.metadata.serviceDate !== serviceDate ||
+            !Number.isFinite(source.windowStart) || !Number.isFinite(source.windowEnd) || source.windowEnd <= source.windowStart)
+            continue;
+        const movementIds = source.movements?.metadata.serviceDate === serviceDate
+            ? new Set(source.movements.trains.map(train => train.id)) : undefined;
+        for (const call of stationCalls(source.snapshot, source.selection, source.policy)) {
+            result.push({ ...call, id: `${encodeURIComponent(source.id)}:${call.id}`, source: source.id,
+                movementAvailable: source.movements ? (movementIds?.has(call.train.id) ?? false) : undefined,
+                windowStart: source.windowStart, windowEnd: source.windowEnd,
+            });
+        }
+    }
+    return result;
+}
+/** Clip to both requested and source windows. Never wrap to an unacquired day. */
+export function upcomingStationCalls(calls, direction, time, windowStart, windowEnd, route = '', maxRows = 4) {
+    if (![time, windowStart, windowEnd].every(Number.isFinite) || time < windowStart || time >= windowEnd || !Number.isSafeInteger(maxRows) || maxRows < 1)
+        return [];
+    const end = Math.min(windowEnd, time + 3600);
+    return calls.filter(call => (direction === 'arrival' ? call.allowsArrival : call.allowsDeparture)
+        && call[direction] >= Math.max(windowStart, call.windowStart ?? windowStart)
+        && call[direction] < Math.min(windowEnd, call.windowEnd ?? windowEnd)
+        && (!route || call.train.route === route) && call[direction] >= time && call[direction] < end)
+        .sort((a, b) => a[direction] - b[direction] || a.id.localeCompare(b.id)).slice(0, maxRows);
+}

package/domain/station-departures.d.ts

@@ -0,0 +1,15 @@
+import type { NetworkSnapshot, ServiceCategory } from './network.ts';
+export interface StationDeparture {
+    readonly id: string;
+    readonly trainId: string;
+    /** Time from the supplied snapshot: realtime-adjusted snapshots contain adjusted times. */
+    readonly time: number;
+    readonly service: string;
+    readonly category: ServiceCategory;
+    readonly destination: string;
+    readonly platform?: string;
+    readonly via: readonly string[];
+    readonly status: 'scheduled' | 'adjusted' | 'cancelled';
+}
+/** Resolve the station against this snapshot, retaining repeat calls but excluding terminators. */
+export declare function stationDepartures(snapshot: NetworkSnapshot, stationName: string): readonly StationDeparture[];

package/domain/station-departures.js

@@ -0,0 +1,25 @@
+/** Resolve the station against this snapshot, retaining repeat calls but excluding terminators. */
+export function stationDepartures(snapshot, stationName) {
+    const stopIndexes = new Set();
+    snapshot.stops.forEach((stop, index) => { if (stop[2] === stationName)
+        stopIndexes.add(index); });
+    if (!stopIndexes.size)
+        return [];
+    const departures = [];
+    for (const train of snapshot.trains) {
+        train.stops.forEach(([stopIndex, , departure], callIndex) => {
+            if (!stopIndexes.has(stopIndex) || !Number.isFinite(departure) || callIndex === train.stops.length - 1)
+                return;
+            const onward = train.stops.slice(callIndex + 1).map(([index]) => snapshot.stops[index]?.[2]).filter((name) => Boolean(name));
+            if (!onward.length)
+                return;
+            const destination = train.headsign.trim() || onward.at(-1);
+            departures.push({ id: `${train.id}:${callIndex}`, trainId: train.id, time: departure,
+                service: train.route || train.shortName, category: train.category, destination,
+                platform: snapshot.stops[stopIndex]?.[3]?.trim() || undefined,
+                via: [...new Set(onward.slice(0, -1).filter((name) => name !== stationName && name !== destination))].slice(0, 3),
+                status: train.realtime?.status ?? 'scheduled' });
+        });
+    }
+    return departures.sort((a, b) => a.time - b.time || a.id.localeCompare(b.id));
+}

package/domain/supported-field.d.ts

@@ -0,0 +1,78 @@
+/** A continuous estimate between scattered instruments. Values are reconstructed from weighted
+ * neighbouring stations; `support` reports how near the closest contributing evidence is, so a
+ * rendering can fade where its evidence weakens. The estimate is a model choice, not an observation
+ * at the sampled place, and missing station values stay missing rather than becoming zero.
+ */
+export interface FieldStation {
+    readonly latitude: number;
+    readonly longitude: number;
+}
+/** Kilometre scales of the neighbour kernel and the support fade. */
+export interface FieldSupportOptions {
+    /** Gaussian scale of neighbour weights. */
+    readonly scaleKm: number;
+    /** Weights taper smoothly from `reachStartKm` to zero at `reachKm`; stations beyond `reachKm` do not contribute. */
+    readonly reachStartKm: number;
+    readonly reachKm: number;
+    /** Support is 1 within `supportNearKm` of the nearest contributing station and fades to 0 at `supportFarKm`. */
+    readonly supportNearKm: number;
+    readonly supportFarKm: number;
+}
+export declare const DEFAULT_FIELD_SUPPORT: FieldSupportOptions;
+export interface FieldNeighbour {
+    readonly index: number;
+    readonly distanceKm: number;
+    readonly weight: number;
+}
+/** One station's contribution at one instant. A null value excludes the station; an incomplete vector excludes it from the vector estimate only. */
+export interface FieldSample {
+    readonly value: number | null;
+    readonly vector?: readonly [east: number, north: number] | null;
+}
+export interface FieldEstimate {
+    readonly value: number | null;
+    readonly vector: readonly [east: number, north: number] | null;
+    /** Fade from the nearest station that supplied a value. */
+    readonly support: number;
+    /** Fade from the nearest station that supplied a complete vector; 0 when none did. */
+    readonly vectorSupport: number;
+}
+export interface FieldGridBounds {
+    readonly west: number;
+    readonly east: number;
+    readonly south: number;
+    readonly north: number;
+    readonly step: number;
+}
+export interface FieldGridCell {
+    readonly latitude: number;
+    readonly longitude: number;
+    readonly neighbours: readonly FieldNeighbour[];
+}
+export interface FieldGrid {
+    readonly width: number;
+    readonly height: number;
+    readonly bounds: FieldGridBounds;
+    readonly cells: readonly FieldGridCell[];
+}
+/** A bilinear reading of a sampled grid. The vector is null when any contributing corner lacks one. */
+export interface FieldGridSample {
+    readonly value: number;
+    readonly vector: readonly [east: number, north: number] | null;
+    readonly support: number;
+}
+/** Great-circle distance on a spherical Earth. */
+export declare function distanceKm(a: FieldStation, b: FieldStation): number;
+/** Stations within reach of a place, weighted by distance. `exclude` withholds one station, for example to test the estimate against it. */
+export declare function fieldNeighbours(stations: readonly FieldStation[], latitude: number, longitude: number, options?: FieldSupportOptions, exclude?: number): FieldNeighbour[];
+/** Weighted estimate from the supplied station samples. Vector components blend as east/north components, never as bearings. */
+export declare function estimateField(neighbours: readonly FieldNeighbour[], sample: (index: number) => FieldSample | null | undefined, options?: FieldSupportOptions): FieldEstimate;
+/** Precompute neighbours for a regular grid. Rows run south to north; the grid includes both bounds. */
+export declare function createFieldGrid(stations: readonly FieldStation[], bounds: FieldGridBounds, options?: FieldSupportOptions): FieldGrid;
+/** Four channels per cell and level: value, east, north, support; levels are the outer dimension.
+ * Unavailable channels are NaN. With `movement`, a cell without a complete vector is entirely
+ * unavailable and its support also fades from the nearest station with a vector.
+ */
+export declare function sampleFieldGrid(grid: FieldGrid, sample: (index: number, level: number) => FieldSample | null | undefined, levels: number, options?: FieldSupportOptions, movement?: boolean): Float32Array;
+/** Bilinear reading of `sampleFieldGrid` output. Null outside the grid or where any contributing corner lacks a value. */
+export declare function sampleFieldGridAt(data: Float32Array, grid: FieldGrid, latitude: number, longitude: number, level: number): FieldGridSample | null;

package/domain/supported-field.js

@@ -0,0 +1,95 @@
+export const DEFAULT_FIELD_SUPPORT = { scaleKm: 90, reachStartKm: 180, reachKm: 240, supportNearKm: 120, supportFarKm: 240 };
+const rad = Math.PI / 180;
+const smooth = (t) => { t = Math.max(0, Math.min(1, t)); return t * t * (3 - 2 * t); };
+const fade = (distance, near, far) => 1 - smooth((distance - near) / Math.max(far - near, 1e-9));
+/** Great-circle distance on a spherical Earth. */
+export function distanceKm(a, b) {
+    const p = (b.latitude - a.latitude) * rad, q = (b.longitude - a.longitude) * rad;
+    const h = Math.sin(p / 2) ** 2 + Math.cos(a.latitude * rad) * Math.cos(b.latitude * rad) * Math.sin(q / 2) ** 2;
+    return 12742.0176 * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+/** Stations within reach of a place, weighted by distance. `exclude` withholds one station, for example to test the estimate against it. */
+export function fieldNeighbours(stations, latitude, longitude, options = DEFAULT_FIELD_SUPPORT, exclude = -1) {
+    const place = { latitude, longitude }, neighbours = [];
+    stations.forEach((station, index) => {
+        const distance = distanceKm(station, place);
+        if (index === exclude || distance >= options.reachKm)
+            return;
+        neighbours.push({ index, distanceKm: distance, weight: Math.exp(-.5 * (distance / options.scaleKm) ** 2) * fade(distance, options.reachStartKm, options.reachKm) });
+    });
+    return neighbours;
+}
+/** Weighted estimate from the supplied station samples. Vector components blend as east/north components, never as bearings. */
+export function estimateField(neighbours, sample, options = DEFAULT_FIELD_SUPPORT) {
+    let weight = 0, value = 0, vectorWeight = 0, east = 0, north = 0, nearest = Infinity, nearestVector = Infinity;
+    for (const n of neighbours) {
+        const s = sample(n.index);
+        if (!s || s.value === null || !Number.isFinite(s.value))
+            continue;
+        weight += n.weight;
+        value += n.weight * s.value;
+        nearest = Math.min(nearest, n.distanceKm);
+        const v = s.vector;
+        if (v && Number.isFinite(v[0]) && Number.isFinite(v[1])) {
+            vectorWeight += n.weight;
+            east += n.weight * v[0];
+            north += n.weight * v[1];
+            nearestVector = Math.min(nearestVector, n.distanceKm);
+        }
+    }
+    if (weight < 1e-12)
+        return { value: null, vector: null, support: 0, vectorSupport: 0 };
+    return { value: value / weight, vector: vectorWeight ? [east / vectorWeight, north / vectorWeight] : null,
+        support: fade(nearest, options.supportNearKm, options.supportFarKm), vectorSupport: vectorWeight ? fade(nearestVector, options.supportNearKm, options.supportFarKm) : 0 };
+}
+/** Precompute neighbours for a regular grid. Rows run south to north; the grid includes both bounds. */
+export function createFieldGrid(stations, bounds, options = DEFAULT_FIELD_SUPPORT) {
+    const width = Math.round((bounds.east - bounds.west) / bounds.step) + 1, height = Math.round((bounds.north - bounds.south) / bounds.step) + 1, cells = [];
+    for (let y = 0; y < height; y++)
+        for (let x = 0; x < width; x++) {
+            const latitude = bounds.south + y * bounds.step, longitude = bounds.west + x * bounds.step;
+            cells.push({ latitude, longitude, neighbours: fieldNeighbours(stations, latitude, longitude, options) });
+        }
+    return { width, height, bounds, cells };
+}
+/** Four channels per cell and level: value, east, north, support; levels are the outer dimension.
+ * Unavailable channels are NaN. With `movement`, a cell without a complete vector is entirely
+ * unavailable and its support also fades from the nearest station with a vector.
+ */
+export function sampleFieldGrid(grid, sample, levels, options = DEFAULT_FIELD_SUPPORT, movement = false) {
+    const data = new Float32Array(grid.cells.length * levels * 4);
+    data.fill(NaN);
+    for (let level = 0; level < levels; level++)
+        for (let i = 0; i < grid.cells.length; i++) {
+            const e = estimateField(grid.cells[i].neighbours, (index) => sample(index, level), options), o = (level * grid.cells.length + i) * 4;
+            if (e.value === null || (movement && !e.vector))
+                continue;
+            data[o] = e.value;
+            data[o + 3] = movement ? Math.min(e.support, e.vectorSupport) : e.support;
+            if (e.vector) {
+                data[o + 1] = e.vector[0];
+                data[o + 2] = e.vector[1];
+            }
+        }
+    return data;
+}
+/** Bilinear reading of `sampleFieldGrid` output. Null outside the grid or where any contributing corner lacks a value. */
+export function sampleFieldGridAt(data, grid, latitude, longitude, level) {
+    const { width, height, bounds } = grid, x = (longitude - bounds.west) / bounds.step, y = (latitude - bounds.south) / bounds.step;
+    if (!(x >= 0 && x <= width - 1 && y >= 0 && y <= height - 1) || level < 0 || (level + 1) * width * height * 4 > data.length)
+        return null;
+    const x0 = Math.floor(x), y0 = Math.floor(y), fx = x - x0, fy = y - y0, out = [0, 0, 0, 0];
+    let vector = true;
+    for (const [xx, yy, w] of [[x0, y0, (1 - fx) * (1 - fy)], [Math.min(x0 + 1, width - 1), y0, fx * (1 - fy)], [x0, Math.min(y0 + 1, height - 1), (1 - fx) * fy], [Math.min(x0 + 1, width - 1), Math.min(y0 + 1, height - 1), fx * fy]]) {
+        if (w < 1e-10)
+            continue;
+        const o = (level * width * height + yy * width + xx) * 4;
+        if (!Number.isFinite(data[o]) || !Number.isFinite(data[o + 3]))
+            return null;
+        if (!Number.isFinite(data[o + 1]) || !Number.isFinite(data[o + 2]))
+            vector = false;
+        for (let c = 0; c < 4; c++)
+            out[c] += data[o + c] * w;
+    }
+    return { value: out[0], vector: vector ? [out[1], out[2]] : null, support: out[3] };
+}

package/domain/vehicle-calls.d.ts

@@ -0,0 +1,11 @@
+import type { NetworkSnapshot, NetworkTrain } from './network.ts';
+export interface VehicleCall {
+    readonly id: string;
+    readonly name: string;
+    readonly time: number;
+    readonly platform?: string;
+    readonly atStop: boolean;
+    readonly isDestination: boolean;
+}
+/** Remaining calls from this snapshot's train. Times may already include realtime adjustments. */
+export declare function vehicleCalls(snapshot: NetworkSnapshot, train: NetworkTrain, time: number): readonly VehicleCall[];

package/domain/vehicle-calls.js

@@ -0,0 +1,14 @@
+/** Remaining calls from this snapshot's train. Times may already include realtime adjustments. */
+export function vehicleCalls(snapshot, train, time) {
+    if (!Number.isFinite(time) || train.realtime?.status === 'cancelled')
+        return [];
+    return train.stops.flatMap(([index, arrival, departure], callIndex) => {
+        const stop = snapshot.stops[index];
+        if (!stop || !Number.isFinite(arrival) || !Number.isFinite(departure) || departure < arrival || departure < time)
+            return [];
+        const atStop = arrival <= time && time <= departure;
+        return [{ id: `${train.id}:${callIndex}`, name: stop[2], time: atStop ? departure : arrival,
+                platform: stop[3]?.trim() || undefined, atStop,
+                isDestination: callIndex === train.stops.length - 1 && Boolean(train.headsign.trim()) && stop[2].trim() === train.headsign.trim() }];
+    });
+}

package/domain/vehicle-counts.d.ts

@@ -0,0 +1,13 @@
+import type { NetworkSnapshot, NetworkTrain, ServiceCategory, StationIndexEntry } from './network.ts';
+export declare function countableVehicleTrains(network: NetworkSnapshot | undefined, stations: readonly StationIndexEntry[], selection: {
+    category?: ServiceCategory;
+    station?: Pick<StationIndexEntry, 'name'>;
+    route?: {
+        name: string;
+        category: ServiceCategory;
+    };
+}): readonly NetworkTrain[];
+/** Build once per immutable selection; clock updates need only two binary searches. */
+export declare function createActiveTimetableVehicleCounter(trains: readonly NetworkTrain[], options?: {
+    readonly requirePositionable?: boolean;
+}): (time: number) => number;

package/domain/vehicle-counts.js

@@ -0,0 +1,33 @@
+export function countableVehicleTrains(network, stations, selection) {
+    const stationTrainIds = selection.station
+        ? new Set(stations.find(station => station.name === selection.station?.name)?.trainIds ?? [])
+        : undefined;
+    return network?.trains.filter(train => (!selection.category || train.category === selection.category) &&
+        (!stationTrainIds || stationTrainIds.has(train.id)) &&
+        (!selection.route || (train.route === selection.route.name && train.category === selection.route.category))) ?? [];
+}
+/** Build once per immutable selection; clock updates need only two binary searches. */
+export function createActiveTimetableVehicleCounter(trains, options = {}) {
+    const starts = [], ends = [];
+    for (const train of trains) {
+        if (train.realtime?.status === 'cancelled' || (options.requirePositionable && train.stops.length < 2) || !(train.start <= train.end))
+            continue;
+        starts.push(train.start);
+        ends.push(train.end);
+    }
+    starts.sort((a, b) => a - b);
+    ends.sort((a, b) => a - b);
+    const before = (values, time, inclusive) => {
+        let low = 0, high = values.length;
+        while (low < high) {
+            const middle = (low + high) >>> 1;
+            if (values[middle] < time || inclusive && values[middle] === time)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        return low;
+    };
+    // Include both departure and arrival instants, including zero-length trips.
+    return time => Number.isNaN(time) ? 0 : before(starts, time, true) - before(ends, time, false);
+}

package/map-labels.d.ts

@@ -0,0 +1,24 @@
+/** Renderer-independent hierarchy shared by station and airport map labels. */
+export interface MapLabelPriority {
+    readonly name: string;
+    readonly rank: number;
+    readonly priority: number;
+    readonly retained: boolean;
+    readonly distance: number;
+}
+export interface MapLabelBox {
+    readonly left: number;
+    readonly right: number;
+    readonly top: number;
+    readonly bottom: number;
+}
+export interface MapLabelCandidate extends MapLabelPriority {
+    readonly box: MapLabelBox;
+}
+export declare function compareMapLabelCandidates(first: MapLabelPriority, second: MapLabelPriority): number;
+export declare function mapLabelBudget(cameraHeight: number): number;
+export declare function mapLabelRankLimit(cameraHeight: number): number;
+export declare function mapLabelBoxesOverlap(box: MapLabelBox, other: MapLabelBox, horizontalGap?: number, verticalGap?: number): boolean;
+/** Candidate boxes include the edition's full hit area. Selected candidates must
+ * already have their higher priority; all labels respect viewport and obstacles. */
+export declare function selectMapLabels<T extends MapLabelCandidate>(candidates: readonly T[], budget: number, viewport: MapLabelBox, obstacles?: readonly MapLabelBox[]): T[];

package/map-labels.js

@@ -0,0 +1,48 @@
+export function compareMapLabelCandidates(first, second) {
+    return first.priority - second.priority || Number(second.retained) - Number(first.retained)
+        || first.rank - second.rank || first.distance - second.distance || first.name.localeCompare(second.name, 'de-CH');
+}
+export function mapLabelBudget(cameraHeight) {
+    if (cameraHeight >= 30)
+        return 8;
+    if (cameraHeight >= 22)
+        return 20;
+    if (cameraHeight >= 15)
+        return 48;
+    return 96;
+}
+export function mapLabelRankLimit(cameraHeight) {
+    if (cameraHeight >= 30)
+        return 8;
+    if (cameraHeight >= 22)
+        return 20;
+    if (cameraHeight >= 15)
+        return 48;
+    if (cameraHeight >= 14)
+        return 96;
+    return Number.POSITIVE_INFINITY;
+}
+export function mapLabelBoxesOverlap(box, other, horizontalGap = 5, verticalGap = 4) {
+    return box.left < other.right + horizontalGap && box.right > other.left - horizontalGap
+        && box.top < other.bottom + verticalGap && box.bottom > other.top - verticalGap;
+}
+/** Candidate boxes include the edition's full hit area. Selected candidates must
+ * already have their higher priority; all labels respect viewport and obstacles. */
+export function selectMapLabels(candidates, budget, viewport, obstacles = []) {
+    const selected = [], occupied = [...obstacles];
+    const limit = Number.isFinite(budget) ? Math.max(0, Math.floor(budget)) : 0;
+    for (const candidate of [...candidates].sort(compareMapLabelCandidates)) {
+        if (selected.length >= limit)
+            break;
+        const box = candidate.box;
+        if (![box.left, box.right, box.top, box.bottom].every(Number.isFinite) || box.right <= box.left || box.bottom <= box.top)
+            continue;
+        if (box.left < viewport.left || box.right > viewport.right || box.top < viewport.top || box.bottom > viewport.bottom)
+            continue;
+        if (occupied.some(other => mapLabelBoxesOverlap(box, other)))
+            continue;
+        selected.push(candidate);
+        occupied.push(box);
+    }
+    return selected;
+}