@motionstudies/core 0.1.0-alpha.0

package/domain/road.js

@@ -0,0 +1,78 @@
+function interpolate(from, to, progress) {
+    return from + (to - from) * progress;
+}
+export function roadConditionsAtTime(direction, time) {
+    const samples = direction.samples;
+    if (!samples.length) {
+        return {
+            lightFlowPerHour: 0,
+            lightSpeedKmh: 0,
+            heavyFlowPerHour: 0,
+            heavySpeedKmh: 0,
+        };
+    }
+    if (time <= samples[0][0]) {
+        const [, lightFlowPerHour, lightSpeedKmh, heavyFlowPerHour, heavySpeedKmh] = samples[0];
+        return { lightFlowPerHour, lightSpeedKmh, heavyFlowPerHour, heavySpeedKmh };
+    }
+    if (time >= samples[samples.length - 1][0]) {
+        const [, lightFlowPerHour, lightSpeedKmh, heavyFlowPerHour, heavySpeedKmh] = samples[samples.length - 1];
+        return { lightFlowPerHour, lightSpeedKmh, heavyFlowPerHour, heavySpeedKmh };
+    }
+    let low = 1;
+    let high = samples.length - 1;
+    while (low < high) {
+        const middle = Math.floor((low + high) / 2);
+        if (samples[middle][0] < time)
+            low = middle + 1;
+        else
+            high = middle;
+    }
+    const from = samples[low - 1];
+    const to = samples[low];
+    const progress = (time - from[0]) / (to[0] - from[0]);
+    return {
+        lightFlowPerHour: interpolate(from[1], to[1], progress),
+        lightSpeedKmh: interpolate(from[2], to[2], progress),
+        heavyFlowPerHour: interpolate(from[3], to[3], progress),
+        heavySpeedKmh: interpolate(from[4], to[4], progress),
+    };
+}
+export function trafficDensity(flowPerHour, speedKmh) {
+    return speedKmh > 0 ? Math.max(0, flowPerHour) / speedKmh : 0;
+}
+export function reconstructedVehicleCount(snapshot, time) {
+    return Math.round(snapshot.corridors.reduce((total, corridor) => total +
+        corridor.directions.reduce((directionTotal, direction) => {
+            const conditions = roadConditionsAtTime(direction, time);
+            return (directionTotal +
+                (trafficDensity(conditions.lightFlowPerHour, conditions.lightSpeedKmh) +
+                    trafficDensity(conditions.heavyFlowPerHour, conditions.heavySpeedKmh)) *
+                    corridor.distanceKm);
+        }, 0), 0));
+}
+export function visualVehicleCount(flowPerHour, speedKmh, distanceKm, sampleRate, maximum) {
+    return Math.min(maximum, Math.max(0, Math.round(trafficDensity(flowPerHour, speedKmh) * distanceKm * sampleRate)));
+}
+export function roadDistanceTravelledKm(direction, time, vehicle) {
+    const samples = direction.samples;
+    if (samples.length < 2 || time <= samples[0][0])
+        return 0;
+    const speedIndex = vehicle === 'light' ? 2 : 4;
+    const limit = Math.min(time, samples[samples.length - 1][0]);
+    let distance = 0;
+    for (let index = 1; index < samples.length; index += 1) {
+        const from = samples[index - 1];
+        const to = samples[index];
+        if (from[0] >= limit)
+            break;
+        const segmentEnd = Math.min(limit, to[0]);
+        const duration = segmentEnd - from[0];
+        const progress = duration / (to[0] - from[0]);
+        const endSpeed = interpolate(from[speedIndex], to[speedIndex], progress);
+        distance += ((from[speedIndex] + endSpeed) / 2) * (duration / 3600);
+        if (segmentEnd === limit)
+            break;
+    }
+    return distance;
+}

package/domain/spatial-layout.d.ts

@@ -0,0 +1,42 @@
+import type { NetworkSnapshot } from './network.ts';
+export type SpatialLayoutCoordinate = readonly [x: number, y: number];
+export type SpatialLayoutStop = readonly [
+    sourceId: string,
+    x: number,
+    y: number
+];
+export interface SpatialLayoutSnapshot {
+    readonly metadata: {
+        readonly id: string;
+        readonly label: string;
+        readonly kind: 'topological';
+        readonly coordinateSpace: 'normalized';
+        readonly sourceNetwork: string;
+        readonly sourceSha256: string;
+        readonly overridesSource?: string;
+        readonly overridesSha256?: string;
+        readonly feedVersion: string;
+        readonly model: string;
+        readonly note: string;
+    };
+    readonly bounds: {
+        readonly minX: number;
+        readonly minY: number;
+        readonly maxX: number;
+        readonly maxY: number;
+    };
+    readonly stops: readonly SpatialLayoutStop[];
+    /** Path indexes deliberately match the source network's `paths` array. */
+    readonly paths: readonly (readonly SpatialLayoutCoordinate[])[];
+    readonly context?: {
+        /** Edition-authored water strokes or other geographic cues in layout space. */
+        readonly waterPaths?: readonly (readonly SpatialLayoutCoordinate[])[];
+    };
+}
+export interface SpatialLayoutCoverage {
+    readonly matchedStops: number;
+    readonly totalStops: number;
+    readonly matchedPaths: number;
+    readonly totalPaths: number;
+}
+export declare function spatialLayoutCoverage(network: NetworkSnapshot, layout: SpatialLayoutSnapshot): SpatialLayoutCoverage;

package/domain/spatial-layout.js

@@ -0,0 +1,12 @@
+export function spatialLayoutCoverage(network, layout) {
+    const layoutStopIds = new Set(layout.stops.map(([sourceId]) => sourceId));
+    const matchedStops = network.stops.reduce((count, stop) => count + Number(Boolean(stop[4] && layoutStopIds.has(stop[4]))), 0);
+    const totalPaths = network.paths?.length ?? 0;
+    const matchedPaths = Math.min(totalPaths, layout.paths.filter((path) => path.length >= 2).length);
+    return {
+        matchedStops,
+        totalStops: network.stops.length,
+        matchedPaths,
+        totalPaths,
+    };
+}

package/domain/train-time-index.d.ts

@@ -0,0 +1,14 @@
+import type { NetworkTrain } from './network.ts';
+export interface TrainTimeIndex {
+    readonly windowStart: number;
+    readonly windowEnd: number;
+    readonly bucketSeconds: number;
+    readonly buckets: readonly (readonly NetworkTrain[])[];
+}
+/**
+ * Groups trips into coarse time buckets so a full-day renderer only examines
+ * services near the current clock time. Padding keeps recent trail samples in
+ * the candidate set around trip boundaries.
+ */
+export declare function buildTrainTimeIndex(trains: readonly NetworkTrain[], windowStart: number, windowEnd: number, paddingSeconds?: number, bucketSeconds?: number): TrainTimeIndex;
+export declare function trainsNearTime(index: TrainTimeIndex, time: number): readonly NetworkTrain[];

package/domain/train-time-index.js

@@ -0,0 +1,28 @@
+const DEFAULT_BUCKET_SECONDS = 15 * 60;
+/**
+ * Groups trips into coarse time buckets so a full-day renderer only examines
+ * services near the current clock time. Padding keeps recent trail samples in
+ * the candidate set around trip boundaries.
+ */
+export function buildTrainTimeIndex(trains, windowStart, windowEnd, paddingSeconds = 0, bucketSeconds = DEFAULT_BUCKET_SECONDS) {
+    const safeBucketSeconds = Math.max(60, bucketSeconds);
+    const bucketCount = Math.max(1, Math.ceil((windowEnd - windowStart) / safeBucketSeconds));
+    const buckets = Array.from({ length: bucketCount }, () => []);
+    for (const train of trains) {
+        const firstBucket = Math.max(0, Math.floor((train.start - paddingSeconds - windowStart) / safeBucketSeconds));
+        const lastBucket = Math.min(bucketCount - 1, Math.floor((train.end + paddingSeconds - windowStart) / safeBucketSeconds));
+        for (let index = firstBucket; index <= lastBucket; index += 1) {
+            buckets[index].push(train);
+        }
+    }
+    return {
+        windowStart,
+        windowEnd,
+        bucketSeconds: safeBucketSeconds,
+        buckets,
+    };
+}
+export function trainsNearTime(index, time) {
+    const bucket = Math.min(index.buckets.length - 1, Math.max(0, Math.floor((time - index.windowStart) / index.bucketSeconds)));
+    return index.buckets[bucket] ?? [];
+}

package/edition.d.ts

@@ -0,0 +1,34 @@
+import type { VisualTheme } from './theme.ts';
+export interface MotionStudyIdentity {
+    readonly series: 'Motion Studies';
+    readonly catalogueNumber: string;
+    readonly title: string;
+    readonly placeName: string;
+    readonly descriptor: string;
+}
+export type SpatialLayoutId = 'geographic' | 'diagram';
+export interface EditionSpatialLayout {
+    readonly id: SpatialLayoutId;
+    readonly label: string;
+    readonly kind: 'geographic' | 'topological';
+    readonly artifact?: string;
+}
+export interface EditionOpeningDataCatalog {
+    readonly network: string;
+    readonly geography?: string;
+    readonly dayManifest?: string;
+    readonly layouts?: readonly EditionSpatialLayout[];
+}
+export interface EditionDataCatalog {
+    readonly opening: EditionOpeningDataCatalog;
+}
+export interface MotionStudyEdition<DataCatalog extends EditionDataCatalog = EditionDataCatalog> {
+    readonly id: string;
+    readonly identity: MotionStudyIdentity;
+    readonly timezone: string;
+    readonly languageStorageKey: string;
+    readonly defaultNetworkTime: number;
+    readonly defaultHubTime?: number;
+    readonly theme: VisualTheme;
+    readonly data: DataCatalog;
+}

package/edition.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,154 @@
+{
+  "name": "@motionstudies/core",
+  "version": "0.1.0-alpha.0",
+  "private": false,
+  "type": "module",
+  "description": "Transport contracts and motion primitives for Motion Studies.",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/emmettl/motionstudies.git",
+    "directory": "packages/core"
+  },
+  "homepage": "https://github.com/emmettl/motionstudies#readme",
+  "bugs": {
+    "url": "https://github.com/emmettl/motionstudies/issues"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/",
+    "tag": "next"
+  },
+  "exports": {
+    "./air-search": {
+      "types": "./air-search.d.ts",
+      "import": "./air-search.js",
+      "default": "./air-search.js"
+    },
+    "./road-search": {
+      "types": "./road-search.d.ts",
+      "import": "./road-search.js",
+      "default": "./road-search.js"
+    },
+    "./search-navigation": {
+      "types": "./search-navigation.d.ts",
+      "import": "./search-navigation.js",
+      "default": "./search-navigation.js"
+    },
+    "./search-text": {
+      "types": "./search-text.d.ts",
+      "import": "./search-text.js",
+      "default": "./search-text.js"
+    },
+    "./edition": {
+      "types": "./edition.d.ts",
+      "import": "./edition.js",
+      "default": "./edition.js"
+    },
+    "./theme": {
+      "types": "./theme.d.ts",
+      "import": "./theme.js",
+      "default": "./theme.js"
+    },
+    "./domain/air-day": {
+      "types": "./domain/air-day.d.ts",
+      "import": "./domain/air-day.js",
+      "default": "./domain/air-day.js"
+    },
+    "./domain/air": {
+      "types": "./domain/air.d.ts",
+      "import": "./domain/air.js",
+      "default": "./domain/air.js"
+    },
+    "./domain/airport": {
+      "types": "./domain/airport.d.ts",
+      "import": "./domain/airport.js",
+      "default": "./domain/airport.js"
+    },
+    "./domain/boundary": {
+      "types": "./domain/boundary.d.ts",
+      "import": "./domain/boundary.js",
+      "default": "./domain/boundary.js"
+    },
+    "./domain/corridor": {
+      "types": "./domain/corridor.d.ts",
+      "import": "./domain/corridor.js",
+      "default": "./domain/corridor.js"
+    },
+    "./domain/hub": {
+      "types": "./domain/hub.d.ts",
+      "import": "./domain/hub.js",
+      "default": "./domain/hub.js"
+    },
+    "./domain/journey": {
+      "types": "./domain/journey.d.ts",
+      "import": "./domain/journey.js",
+      "default": "./domain/journey.js"
+    },
+    "./domain/lakes": {
+      "types": "./domain/lakes.d.ts",
+      "import": "./domain/lakes.js",
+      "default": "./domain/lakes.js"
+    },
+    "./domain/map-reference": {
+      "types": "./domain/map-reference.d.ts",
+      "import": "./domain/map-reference.js",
+      "default": "./domain/map-reference.js"
+    },
+    "./domain/network-day": {
+      "types": "./domain/network-day.d.ts",
+      "import": "./domain/network-day.js",
+      "default": "./domain/network-day.js"
+    },
+    "./domain/network-layers": {
+      "types": "./domain/network-layers.d.ts",
+      "import": "./domain/network-layers.js",
+      "default": "./domain/network-layers.js"
+    },
+    "./domain/network": {
+      "types": "./domain/network.d.ts",
+      "import": "./domain/network.js",
+      "default": "./domain/network.js"
+    },
+    "./domain/operations": {
+      "types": "./domain/operations.d.ts",
+      "import": "./domain/operations.js",
+      "default": "./domain/operations.js"
+    },
+    "./domain/realtime": {
+      "types": "./domain/realtime.d.ts",
+      "import": "./domain/realtime.js",
+      "default": "./domain/realtime.js"
+    },
+    "./domain/road-day": {
+      "types": "./domain/road-day.d.ts",
+      "import": "./domain/road-day.js",
+      "default": "./domain/road-day.js"
+    },
+    "./domain/road": {
+      "types": "./domain/road.d.ts",
+      "import": "./domain/road.js",
+      "default": "./domain/road.js"
+    },
+    "./domain/spatial-layout": {
+      "types": "./domain/spatial-layout.d.ts",
+      "import": "./domain/spatial-layout.js",
+      "default": "./domain/spatial-layout.js"
+    },
+    "./domain/train-time-index": {
+      "types": "./domain/train-time-index.d.ts",
+      "import": "./domain/train-time-index.js",
+      "default": "./domain/train-time-index.js"
+    }
+  },
+  "files": [
+    "**/*.js",
+    "**/*.mjs",
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.css",
+    "README.md",
+    "LICENSE"
+  ],
+  "sideEffects": false
+}

package/road-search.d.ts

@@ -0,0 +1,11 @@
+export interface RoadSearchCorridor {
+    readonly id: string;
+    readonly label: string;
+    readonly officialLabel: string;
+    readonly description?: string;
+    readonly focus: readonly [longitude: number, latitude: number];
+    readonly cameraScale: number;
+    readonly stationCount?: number;
+}
+export declare function searchRoadCorridors<Road extends RoadSearchCorridor>(roads: readonly Road[], query: string, maximum?: number): readonly Road[];
+export declare function roadCorridorSearchValue(road: RoadSearchCorridor): string;

package/road-search.js

@@ -0,0 +1,24 @@
+import { foldSearchText } from './search-text.js';
+const ROAD_TERMS = 'motorway autobahn autoroute autostrada autostrasse';
+function searchText(road) {
+    return foldSearchText(`${road.label} ${road.officialLabel} ${road.description ?? ''} ${ROAD_TERMS}`);
+}
+export function searchRoadCorridors(roads, query, maximum = 5) {
+    const foldedQuery = foldSearchText(query);
+    if (!foldedQuery)
+        return [];
+    return roads
+        .filter((road) => searchText(road).includes(foldedQuery))
+        .sort((first, second) => {
+        const firstText = searchText(first);
+        const secondText = searchText(second);
+        return (Number(secondText.startsWith(foldedQuery)) -
+            Number(firstText.startsWith(foldedQuery)) ||
+            (second.stationCount ?? 0) - (first.stationCount ?? 0) ||
+            first.id.localeCompare(second.id, 'en', { numeric: true }));
+    })
+        .slice(0, maximum);
+}
+export function roadCorridorSearchValue(road) {
+    return road.description ? `${road.label} · ${road.description}` : road.label;
+}

package/search-navigation.d.ts

@@ -0,0 +1,2 @@
+export type SearchNavigationKey = 'ArrowDown' | 'ArrowUp' | 'Home' | 'End';
+export declare function nextSearchResultIndex(currentIndex: number, resultCount: number, key: SearchNavigationKey): number;

package/search-navigation.js

@@ -0,0 +1,14 @@
+export function nextSearchResultIndex(currentIndex, resultCount, key) {
+    if (resultCount <= 0)
+        return -1;
+    if (key === 'Home')
+        return 0;
+    if (key === 'End')
+        return resultCount - 1;
+    if (key === 'ArrowDown') {
+        return currentIndex < 0 ? 0 : (currentIndex + 1) % resultCount;
+    }
+    return currentIndex < 0
+        ? resultCount - 1
+        : (currentIndex - 1 + resultCount) % resultCount;
+}

package/search-text.d.ts

@@ -0,0 +1 @@
+export declare function foldSearchText(value: string): string;

package/search-text.js

@@ -0,0 +1,12 @@
+const combiningMarks = /\p{Mark}+/gu;
+export function foldSearchText(value) {
+    return value
+        .trim()
+        .toLocaleLowerCase('de-CH')
+        .normalize('NFD')
+        .replace(combiningMarks, '')
+        .replaceAll('ß', 'ss')
+        .replaceAll('ae', 'a')
+        .replaceAll('oe', 'o')
+        .replaceAll('ue', 'u');
+}

package/theme.d.ts

@@ -0,0 +1,19 @@
+import type { ServiceCategory } from './domain/network.ts';
+export interface VisualTheme {
+    readonly background: string;
+    readonly ink: string;
+    readonly muted: string;
+    readonly line: string;
+    readonly primary: string;
+    readonly secondary: string;
+    readonly panel: string;
+    readonly air: string;
+    readonly roadLight: string;
+    readonly roadHeavy: string;
+}
+export declare const SERVICE_CATEGORIES: ReadonlyArray<{
+    readonly id: ServiceCategory;
+    readonly label: string;
+    readonly color: string;
+}>;
+export declare const SERVICE_COLORS: Readonly<Record<ServiceCategory, string>>;

package/theme.js

@@ -0,0 +1,16 @@
+export const SERVICE_CATEGORIES = [
+    { id: 'international', label: 'International', color: '#ffd166' },
+    { id: 'intercity', label: 'IC', color: '#ff4fd8' },
+    { id: 'interregio', label: 'IR', color: '#9d7bff' },
+    { id: 'regional-express', label: 'RE', color: '#4fc3ff' },
+    { id: 's-bahn', label: 'S-Bahn', color: '#7dffbb' },
+    { id: 'regional', label: 'Regional', color: '#fff3a6' },
+    { id: 'tram', label: 'Tram', color: '#ff6ea9' },
+    { id: 'metro', label: 'Metro', color: '#a78bfa' },
+    { id: 'bus', label: 'Bus', color: '#ff9f43' },
+    { id: 'ferry', label: 'Ferry', color: '#48c6ef' },
+    { id: 'cableway', label: 'Cableway', color: '#d7ff70' },
+    { id: 'funicular', label: 'Funicular', color: '#f8f38d' },
+    { id: 'other', label: 'Other', color: '#b9c1da' },
+];
+export const SERVICE_COLORS = Object.fromEntries(SERVICE_CATEGORIES.map((category) => [category.id, category.color]));