mobility-toolbox-js 2.0.1-beta.13 → 2.2.0-beta.0

package/types/common.d.ts

@@ -0,0 +1,122 @@
+import { Feature } from 'ol';
+import { Coordinate } from 'ol/coordinate';
+import { ObjectEvent } from 'ol/Object';
+import { Pixel } from 'ol/pixel';
+import type { RealtimeMot, RealtimeTrainId } from './realtime';
+import type {
+  CopyrightControl as MbCopyrightControl,
+  RealtimeLayer as MbRealtimeLayer,
+  layer as MbLayer,
+} from '../mapbox';
+import type {
+  CopyrightControl as OlCopyrightControl,
+  MapboxLayer,
+  MaplibreLayer,
+  RealtimeLayer as OlRealtimeLayer,
+  layer as OlLayer,
+} from '../ol';
+import { RealtimeTrajectory } from '../api/typedefs';
+import CommonLayer, { LayerCommonOptions } from '../common/layers/LayerCommon';
+import type { RoutingParameters } from '.';
+
+export type StyleCache = { [key: string]: AnyCanvas };
+
+export type ViewState = {
+  time?: number;
+  center?: number[];
+  extent?: number[];
+  size?: number[];
+  rotation?: number;
+  resolution?: number;
+  zoom?: number;
+  pixelRatio?: number;
+};
+
+export type RealtimeStyleOptions = {
+  hoverVehicleId?: RealtimeTrainId;
+  selectedVehicleId?: RealtimeTrainId;
+  useDelayStyle?: boolean;
+  delayOutlineColor?: string;
+  delayDisplay?: number;
+  noInterpolate?: boolean;
+  filter?: FilterFunction;
+  getRadius?: (type: RealtimeMot, z: number) => number;
+  getBgColor?: (type: RealtimeMot) => string;
+  getDelayColor?: (
+    delay: number | null,
+    cancelled?: boolean,
+    isDelayText?: boolean,
+  ) => string;
+  getDelayText?: (delay: number | null, cancelled?: boolean) => string;
+  getTextColor?: (type: RealtimeMot) => string;
+  getTextSize?: (
+    ctx: AnyCanvasContext,
+    markerSize: number,
+    name: string,
+    fontSize: number,
+  ) => number;
+  getMaxRadiusForText?: () => number;
+  getMaxRadiusForStrokeAndDelay?: () => number;
+  getScreenPixel?: (pixel: Pixel, viewState: ViewState) => Pixel;
+};
+
+export type RealtimeTrajectories = {
+  [key: RealtimeTrainId]: RealtimeTrajectory;
+};
+
+export type RealtimeStyleFunction = (
+  trajectory: RealtimeTrajectory,
+  viewState: ViewState,
+  options: RealtimeStyleOptions,
+) => AnyCanvas | null;
+
+export type RealtimeRenderState = {
+  center?: Coordinate;
+  zoom?: number;
+  rotation?: number;
+  renderedTrajectories?: RealtimeTrajectory[];
+};
+
+export type AnyMap = OlMap | MaplibreMap | MapboxMap;
+export type AnyLayer = OlLayer | MbLayer;
+export type AnyOlLayer = OlLayer;
+export type AnyMapboxLayer = MapboxLayer | MaplibreLayer;
+export type AnyRealtimeLayer = MbRealtimeLayer | OlRealtimeLayer;
+export type AnyCopyrightControl = MbCopyrightControl | OlCopyrightControl;
+export type AnyMapboxMap = mapboxgl.Map | maplibregl.Map;
+export type AnyCanvas = HTMLCanvasElement | OffscreenCanvas;
+export type AnyCanvasContext =
+  | CanvasRenderingContext2D
+  | OffscreenCanvasRenderingContext2D;
+export type GConstructor<T extends CommonLayer> = new (options?: any) => T;
+export type CommonLayerClass = GConstructor<CommonLayer>;
+export type GConstructor2<T extends OlLayer> = new (options?: any) => T;
+export type OlLayerClass = GConstructor<AnyOlLayer>;
+export type AnyLayerClass = GConstructor<AnyLayer>;
+
+export type AnyMapboxLayerClass = GConstructor<AnyMapboxLayer>;
+export type AnyRealtimeLayerClass = GConstructor<AnyRealtimeLayer>;
+export type AnyMapboxMapClass = GConstructor<AnyMapboxMap>;
+export type AnyCopyrightControlClass = GConstructor<AnyCopyrightControl>;
+
+export type LayerGetFeatureInfoResponse = {
+  layer: Layer;
+  features: Feature[];
+  coordinate: Coordinate;
+};
+
+export type LayerGetFeatureInfoOptions = {
+  resolution: number;
+  nb?: number;
+};
+
+export type UserInteractionCallback = (
+  features: Feature[],
+  layer: LayerCommonOptions,
+  coordinate: Coordinate,
+  event: ObjectEvent,
+) => void;
+
+export type RoutingGraph = [RoutingParameters.graph, number, number];
+export type RoutingMot = RoutingParameters.mot;
+export type RoutingViaPoint = string | Coordinate;

package/types/index.d.ts

@@ -0,0 +1,13 @@
+import { Paths as Routing } from './routing';
+import { Paths as Stops } from './stops';
+
+export * from './realtime';
+export * from './common';
+
+export type RoutingParameters = Routing['/']['get']['parameters']['query'];
+export type RoutingResponse = Routing['/']['get']['responses']['200']['schema'];
+
+export type StopsParameters = Stops['/']['get']['parameters']['query'];
+export type StopsResponse = Stops['/']['get']['responses']['200']['schema'];
+
+export type RealtimeVersion = '1' | '2';

package/types/realtime.d.ts

@@ -0,0 +1,320 @@
+import { Feature, FeatureCollection, Point } from 'geojson';
+
+export declare type RealtimeMode = 'topographic' | 'schematic' | 'raw';
+
+export declare type RealtimeChannelModeSuffix = '' | '_schematic';
+
+export type RealtimeTrainId = string;
+
+export type RealtimeStationId = number;
+
+export type RealtimeService =
+  | 'redis_websocket_api'
+  | 'tralis_stations'
+  | 'tralis_fzo'
+  | 'tralis_worker'
+  | 'tralis_vdv'
+  | 'tralis_newsticker'
+  | 'tralis_geofox'
+  | string;
+
+export type RealtimeTenant = 'sbb' | 'sbh' | 'sbm' | '' | string;
+
+export type RealtimeElevatorState = 'ALL_OPERABLE' | string;
+
+export type RealtimeStopState = 'LEAVING' | 'BOARDING' | string;
+
+export type RealtimeTrajectoryState =
+  | 'HIDDEN'
+  | 'BOARDING'
+  | 'STOP_CANCELLED'
+  | 'JOURNEY_CANCELLED';
+
+export type RealtimeGeneralizationLevel = 5 | 10 | 30 | 100;
+
+export type RealtimeMot =
+  | 'tram'
+  | 'subway'
+  | 'rail'
+  | 'bus'
+  | 'ferry'
+  | 'cablecar'
+  | 'gondola'
+  | 'funicular'
+  | 'coach';
+
+export type RealtimeChannelName =
+  | 'websocket'
+  | 'buffer'
+  | 'line'
+  | 'extra_geoms'
+  | 'healthcheck'
+  | `timetable_${RealtimeStationId}`
+  | `trajectory${RealtimeChannelModeSuffix}`
+  | `deleted_vehicles${RealtimeChannelModeSuffix}`
+  | `stopsequence_${RealtimeTenant}_${RealtimeTrainId}`
+  | `full_trajectory${RealtimeChannelModeSuffix}_${RealtimeTenant}_${RealtimeTrainId}`;
+
+export interface RealtimeTrajectoryProperties {
+  // Tralis and trafimage
+  bounds: [number, number, number, number];
+  delay: number | null;
+  event_timestamp: number;
+  gen_level?: RealtimeGeneralizationLevel;
+  gen_range: [number, number];
+  has_journey: boolean;
+  has_realtime: boolean;
+  has_realtime_journey: boolean;
+  line?: RealtimeLine;
+  operator_provides_realtime_journey: 'unknown' | 'yes' | 'no';
+  rake?: string;
+  raw_time?: string;
+  route_identifier: string;
+  state: RealtimeTrajectoryState;
+  tenant: string;
+  time_intervals?: Array<Array<number>>;
+  time_since_update?: string;
+  timestamp: number;
+  train_id?: RealtimeTrainId;
+  train_number?: number;
+  type: RealtimeMots;
+
+  operator?: string; // deprecated, operator is an old property, use tenant instead.
+  name?: string; // deprecated, name is an old property, use line.name instead.
+
+  // Tralis
+  event?: string;
+  event_delay?: number;
+  event_timestamp?: number;
+  original_line?: RealtimeLine;
+  original_rake?: string;
+  original_train_number?: number;
+  position_correction?: number;
+  raw_coordinates?: [number, number];
+  ride_state?: string;
+  routeIdentifier?: string;
+  transmitting_vehicle?: string;
+}
+
+export interface RealtimeTrajectory extends Feature {
+  properties: RealtimeTrajectoryProperties;
+}
+
+export interface RealtimeFullTrajectoryProperties {
+  gen_level?: RealtimeGeneralizationLevel;
+  gen_range: [number, number];
+  license?: string;
+  licenseNote?: string;
+  licenseUrl?: string;
+  operator?: string;
+  operatorUrl?: string;
+  publisher?: string;
+  publisherUrl?: string;
+  tenant: RealtimeTenant;
+  train_id: RealtimeTrainId;
+}
+
+export interface RealtimeFullTrajectory extends FeatureCollection {
+  properties: RealtimeFullTrajectoryProperties;
+}
+
+export interface RealtimeStop {
+  aimedArrivalTime: number;
+  aimedDepartureTime: number;
+  arrivalDelay?: number;
+  arrivalTime: number;
+  cancelled: booblean;
+  coordinate: number[];
+  departureDelay: number;
+  departureTime: number;
+  noDropOff?: boolean;
+  noPickUp?: boolean;
+  state?: RealtimeStopState;
+  stationId: RealtimeStationId;
+  stationName: string;
+}
+
+export interface RealtimeStopSequence {
+  backgroundColor?: string;
+  color?: string;
+  destination: string;
+  id: RealtimeTrainId;
+  license?: string;
+  licenseNote?: string;
+  licenseUrl?: string;
+  longName?: string;
+  new_destination?: string;
+  operator?: string;
+  operatorUrl?: string;
+  publisher?: string;
+  publisherUrl?: string;
+  routeIdentifier: string;
+  shortName: string;
+  stations: RealtimeStop[];
+  stroke?: strinealtimeTenant;
+  text_color: string;
+  type: RealtimeMot;
+  vehicleType: number;
+}
+
+export interface RealtimeExtraGeomProperties {
+  ref: string | number;
+}
+
+export interface RealtimeExtraGeom extends Feature {
+  properties: RealtimeExtraGeomProperties;
+}
+
+export interface RealtimeExtraGeomDeleted {
+  type: 'Deleted';
+  properties: RealtimeExtraGeomProperties;
+}
+
+export type RealtimeExtraGeoms = {
+  [index: string]: Feature[];
+};
+
+export interface RealtimeLine {
+  id: number;
+  color: string;
+  stroke: string;
+  name: string;
+  text_color: string;
+}
+
+export interface RealtimeTransfer {
+  mot: RealtimeMot;
+  lines: string[];
+}
+
+export interface RealtimeStationproperties extends Feature {
+  transfers: RealtimeTransfer[];
+  elevatorOutOfOrder: boolean;
+  elevatorState: RealtimeElevatorState;
+  elevators: object;
+  uic: RealtimeStationId;
+  name: string;
+  networkLines: RealtimeLine[];
+  hasElevator: boolean;
+  hasZOB: boolean;
+  hasAccessibility: boolean;
+  hasAirport: boolean;
+  tenant: RealtimeTenant;
+}
+
+export interface RealtimeStation extends Feature {
+  geometry: Point;
+  properties: RealtimeStationproperties;
+}
+
+export interface RealtimeDeparture {
+  to: string[];
+  time: number;
+  no_stop_between: boolean;
+  new_to: boolean;
+  has_fzo: boolean;
+  next_stoppoints: string[];
+  platform: string;
+  created_at: string;
+  at_station_ds100: string;
+  train_number: number;
+  ris_aimed_time: number;
+  updated_at: number;
+  min_arrival_time: number;
+  ris_estimated_time: number;
+  train_id: RealtimeTrainId;
+  fzo_estimated_time: number;
+  train_type: number;
+  call_id: number;
+  line: RealtimeLine;
+  state: string; /// (BOARDING|STOP_CANCELLED|JOURNEY_CANCELLED|HIDDEN)/
+  formation: any;
+  no_stop_till: any;
+  timestamp: number; // This property seems to never exists
+  timediff: number; // This property seems to alawy been 0
+}
+
+export interface RealtimeDepartureExtended extends RealtimeDeparture {
+  cancelled?: boolean; // value generated by RealtimeAPI class
+}
+
+export interface RealtimeNewsMessage {
+  content: string;
+  lines: RealtimeLine[];
+  title: string;
+  updated: string; // TODO: ISO string
+}
+
+export interface RealtimeNews {
+  incident_program: boolean;
+  messages: RealtimeNewsMessage[];
+}
+
+export interface RealtimeHealth {
+  heathly: boolean;
+  service: RealtimeService;
+  tenant: string | null;
+}
+
+export interface RealtimeExtraGeomsResponse {
+  source: `extra_geoms`;
+  timestamp: number;
+  client_reference: null;
+  content: RealtimeExtraGeom | RealtimeExtraGeomDeleted;
+}
+
+export interface RealtimeStationResponse {
+  source: `station_${RealtimeStationId}`;
+  timestamp: number;
+  client_reference: null;
+  content: RealtimeNews;
+}
+
+export interface RealtimeNewsTickerResponse {
+  source: `${RealtimeTenant}_newsticker`;
+  timestamp: number;
+  client_reference: null;
+  content: RealtimeNews;
+}
+
+export interface RealtimeTimetableResponse {
+  source: `timetable_${RealtimeStationId}`;
+  timestamp: number;
+  client_reference: null;
+  content: RealtimeDeparture;
+}
+
+export interface RealtimeTrajectoryResponse {
+  source: `trajectory${RealtimeChannelModeSuffix}`;
+  timestamp: number;
+  client_reference: '';
+  content: RealtimeTrajectory;
+}
+
+export interface RealtimeStopSequenceResponse {
+  source: `stopsequence_${RealtimeTenant}_${RealtimeTrainId}`;
+  timestamp: number;
+  client_reference: '';
+  content: Array<RealtimeStopSequence>;
+}
+
+export interface RealtimeBufferResponse {
+  source: 'buffer';
+  timestamp: number;
+  client_reference: '';
+  content: RealtimeTrajectoryResponse[];
+}
+
+export interface RealtimeDeletedVehiclesResponse {
+  source: `deleted_vehicles${RealtimeChannelModeSuffix}`;
+  timestamp: number;
+  client_reference: null;
+  content: string;
+}
+
+export interface RealtimeHealthCheckResponse {
+  source: 'healthcheck';
+  timestamp: number;
+  client_reference: null;
+  content: RealtimeHealth;
+}

package/types/routing.d.ts

@@ -0,0 +1,206 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface Paths {
+  '/': {
+    /** Returns a route as GeoJSON */
+    get: {
+      parameters: {
+        query: {
+          /**
+           * A pipe separated list of hops. A hop describes a station with either
+           *  - a name or abbreviation
+           *  - a station id, prefixed with `!`
+           *  - comma-seperated coordinates starting with geographic latitude followed by longitude, prefixed with `@`
+           *  - an additional platform code, prefixed with `$`
+           *
+           *  Station names do not need to match exactly the names in the
+           *  database that is used for routing. The correct names are searched
+           *  for by simple normalization, by lookup of synonyms or abbreviation
+           *  as well as fuzzy algorithms.
+           *
+           *  The usage of different schemes of IDs used by the transit agencies
+           *  is handled to a large part. A station can be found by all IDs that
+           *  we know for it. E.g. the station Basel Bad can be found with the ID
+           *  8500090 that is used by Swiss Federal Railways SBB and by 8518816,
+           *  the number used by German Railways DB. Also the usage of numbers
+           *  used by the UIC is supported for many stations. If you need an
+           *  additional numbering scheme please contact us.
+           *
+           *  Note on coordinates:
+           *    If you do not prefix the coordinate pair with `@`, no snapping to
+           *    the next station is performed. Instead the route will forcefully
+           *    traverse the specified point.
+           *
+           * Note on mot's "foot" and "car":
+           *    Some features might not be available, such as "line-from",
+           *    "line-to", because they dont apply to those means of transport.
+           *
+           *  Examples for a single hop:
+           *  - `@47.37811,8.53935` a station at position 47.37811, 8.53935
+           *  - `basel sbb` a station named "basel sbb"
+           *  - `ZUE`, station "Zürich HB" by its common abbreviation
+           *  - `Zürich Hauptbahnhof` or `HBF Zürich` are all valid synonyms für "Zürich HB"
+           *  - `!8596126` a station with id 8596126
+           *  - `basel sbb$4` track 4 in a station "Basel SBB"
+           *  - `@47.37811,8.53935$4` track 4 in a station at position 47.37811, 8.53935
+           *  - `zürich hb@47.37811,8.53935$8` track 8 in station "Zürich HB" at position 47.37811, 8.53935
+           *
+           *  Example for a valid via with three hops:
+           *  - `freiburg|basel%20sbb|bern` - from Freiburg (Breisgau) Hbf via Basel SBB to Bern
+           */
+          via: string;
+          /** Mode of transport */
+          mot:
+            | 'rail'
+            | 'bus'
+            | 'coach'
+            | 'foot'
+            | 'tram'
+            | 'subway'
+            | 'gondola'
+            | 'funicular'
+            | 'ferry'
+            | 'car';
+          /** Only for mot=rail. Default is a detailed network based on OpenStreetMap. gen1 to gen4 provide rail networks with increasing levels of generalization */
+          graph?: 'gen1' | 'gen2' | 'gen3' | 'gen4';
+          /** A line name that should be preferred */
+          line?: string;
+          /** Name of origin of the preferred line */
+          'line-from'?: string;
+          /** Name of destination of the preferred line */
+          'line-to'?: string;
+          /** Douglas-Peucker distance parameter for simplification. Default 0.5 in Mercator units */
+          simplify?: number;
+          /**
+           * Maximum allowed ratio of hops to skip if not found. Only non-start
+           * and non-end hops are counted in ratio numerator and denominator.
+           */
+          'max-skip-hop-ratio'?: number;
+          /**
+           * Whether to include intermediate hops (stations/stops) found on the
+           * route to the response. "true", "on", "yes", "y", "1" will enable
+           * intermediate hops. Default: disabled
+           */
+          hops?: string;
+          /**
+           * Whether to use beelines (line strings with 2 points) between
+           * mutually unreachable hops as a fallback for "Route not found"
+           * errors. "true", "on", "yes", "y", "1" will enable the
+           * fallback. Default: enabled
+           */
+          'beeline-fallback'?: string;
+          /**
+           * Search radius for candidate edges during snapping of coordinates
+           * (see "Note on coordinates" at the top) Default: -1.0
+           */
+          'coord-radius'?: number;
+          /**
+           * Distance punishment factor for edge snapping of coordinates (see
+           * "Note on coordinates" at the top). Large: prefer close edge. Small:
+           * prefer short total route. Negative value: like worst edge
+           * category. Default: -1.0
+           */
+          'coord-punish'?: number;
+          /**
+           * Whether to output OSM way ids in Feature properties.
+           * "true", "on", "yes", "y", "1" will enable output. Default: disabled
+           */
+          'way-ids'?: string;
+        };
+      };
+      responses: {
+        /** A route */
+        200: {
+          schema: {
+            features?: {
+              geometry?: {
+                /**
+                 * @example [
+                 *   [
+                 *     7.8958421,
+                 *     47.9816362
+                 *   ],
+                 *   [
+                 *     7.9048287,
+                 *     47.9796056
+                 *   ]
+                 * ]
+                 */
+                coordinates?: number[][];
+                /** @enum {string} */
+                type?: 'LineString';
+              };
+              properties?: {
+                lines?: {
+                  /** @example ICE */
+                  name?: string;
+                  /** @example 0.99 */
+                  prop?: number;
+                }[];
+              };
+              station_from?: {
+                /**
+                 * @description IBNR
+                 * @example
+                 */
+                id?: string;
+                /** @example Freiburg Littenweiler */
+                name?: string;
+                /** @example 1 */
+                platform?: string;
+                /** @description Latitude of the stop, in WGS84 */
+                latitude?: number;
+                /** @description Latitude of the stop, in WGS84 */
+                longitude?: number;
+              };
+              station_to?: {
+                /**
+                 * @description IBNR
+                 * @example 8004158
+                 */
+                id?: string;
+                /** @example Muenchen Pasing */
+                name?: string;
+                /** @example 4 */
+                platform?: string;
+                /** @description Latitude of the stop, in WGS84 */
+                latitude?: number;
+                /** @description Latitude of the stop, in WGS84 */
+                longitude?: number;
+              };
+              /** @enum {string} */
+              type?: 'Feature';
+            };
+            properties?: {
+              lines?: {
+                /** @example ICE */
+                name?: string;
+                /** @example 0.99 */
+                prop?: number;
+              }[];
+              /**
+               * @description routing was done on this graph
+               * @example osm-eu-rail
+               */
+              network?: string;
+              /**
+               * @description via's you passed as a parameter but were
+               * skipped when routing (maybe because they were not found)
+               */
+              skippedVias?: string[];
+            };
+            /** @enum {string} */
+            type?: 'FeatureCollection';
+          };
+        };
+      };
+    };
+  };
+}
+
+export interface Operations {}
+
+export interface External {}