mobility-toolbox-js 2.0.0-beta.46 → 2.0.0-beta.47

package/types/common.d.ts

@@ -0,0 +1,111 @@
+import { Feature } from 'ol';
+import { Coordinate } from 'ol/coordinate';
+import { ObjectEvent } from 'ol/Object';
+import type { RealtimeTrainId } from './realtime';
+import type {
+  CopyrightControl as MbCopyrightControl,
+  RealtimeLayer as MbRealtimeLayer,
+  layer as MbLayer,
+} from '../mapbox';
+import type {
+  CopyrightControl as OlCopyrightControl,
+  MapboxLayer,
+  RealtimeLayer as OlRealtimeLayer,
+  layer as OlLayer,
+} from '../ol';
+import { RealtimeTrajectory } from '../api/typedefs';
+import CommonLayer, { LayerCommonOptions } from '../common/layers/LayerCommon';
+
+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;
+  getRadius?: (type: number, z: number) => number;
+  getBgColor?: (type: number) => string;
+  getDelayColor?: (
+    delay: number | null,
+    cancelled?: boolean,
+    isDelayText?: boolean,
+  ) => string;
+  getDelayText?: (delay: number | null, cancelled?: boolean) => string;
+  getTextColor?: (type: number) => string;
+  getTextSize?: (
+    ctx: AnyCanvasContext | null,
+    markerSize: number,
+    name: string,
+    fontSize: number,
+  ) => number;
+};
+
+export type RealtimeTrajectories = {
+  [key: RealtimeTrainId]: RealtimeTrajectory;
+};
+
+export type RealtimeStyleFunction = (
+  trajectory: RealtimeTrajectory,
+  viewState: ViewState,
+  options: RealtimeStyleOptions,
+) => CanvasImageSource;
+
+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;

package/types/index.d.ts

@@ -2,6 +2,7 @@ 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'];

package/types/realtime.d.ts

@@ -1,24 +1,305 @@
-import { Feature } from 'geojson';
+import { Feature, FeatureCollection, Point } from 'geojson';
 
-export interface RealtimeTrajectory extends Feature {}
+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;
+  routeIdentifier: string;
+  state: RealtimeTrajectoryState;
+  tenant: string;
+  time_intervals?: Array<Array<number>>;
+  time_since_update?: string;
+  timestamp: number;
+  train_id?: RealtimeTrainId;
+  train_number?: number;
+  type: RealtimeMots;
+
+  // TODO: verify why these properties are used in createTrackerFilter
+  operator?: string; // TODO not sure if this property exists, see createTrackerFilter code.
+  name?: string; // TODO not sure if this property exists, see createTrackerFilter code.
+}
+
+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;
+  arrivalTimeWithDelay: number; // TODO: add by cleanStopTime function
+  departureTimeWithDelay: number; // TODO: add by cleanStopTime function
+}
+
+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 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;
+}
+
+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 {
-  train_id: 'trajectory';
+  source: `trajectory${RealtimeChannelModeSuffix}`;
+  timestamp: number;
+  client_reference: '';
+  content: RealtimeTrajectory;
+}
+
+export interface RealtimeStopSequenceResponse {
+  source: `stopsequence_${RealtimeTenant}_${RealtimeTrainId}`;
   timestamp: number;
   client_reference: '';
-  content: [RealtimeTrajectory];
+  content: Array<RealtimeStopSequence>;
 }
 
 export interface RealtimeBufferResponse {
   source: 'buffer';
   timestamp: number;
   client_reference: '';
-  content: [RealtimeTrajectoryResponse];
+  content: RealtimeTrajectoryResponse[];
+}
+
+export interface RealtimeDeletedVehiclesResponse {
+  source: `deleted_vehicles${RealtimeChannelModeSuffix}`;
+  timestamp: number;
+  client_reference: null;
+  content: string;
 }
 
-export interface RealtimeResponse {
-  source: string;
+export interface RealtimeHealthCheckResponse {
+  source: 'healthcheck';
   timestamp: number;
-  client_reference: 'None';
-  content: [RealtimeBufferResponse];
+  client_reference: null;
+  content: RealtimeHealth;
 }

package/api/RealtimeAPI.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RealtimeAPI.test.d.ts.map

package/api/RealtimeAPI.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RealtimeAPI.test.d.ts","sourceRoot":"","sources":["../../src/api/RealtimeAPI.test.js"],"names":[],"mappings":""}

package/api/RealtimeAPI.test.js

@@ -1,67 +0,0 @@
-import { RealtimeAPI, RealtimeModes } from '.';
-describe('RealtimeAPI', () => {
-    let api;
-    let get;
-    beforeEach(() => {
-        get = jest.fn((params, cb) => {
-            cb({ content: 'content' });
-        });
-        api = new RealtimeAPI();
-        api.wsApi = {
-            get,
-        };
-    });
-    describe('#getFullTrajectory() calls fullTrajectory channel', () => {
-        test('without parameters', (done) => {
-            api.getFullTrajectory().then(() => {
-                expect(get.mock.calls.length).toBe(1);
-                expect(get.mock.calls[0][0]).toEqual({
-                    channel: 'full_trajectory',
-                });
-                done();
-            });
-        });
-        [null, RealtimeModes.TOPOGRAPHIC].forEach((mode) => {
-            describe(`using mode ${mode}`, () => {
-                test('using id', (done) => {
-                    api.getFullTrajectory('foo', mode).then(() => {
-                        expect(get.mock.calls.length).toBe(1);
-                        expect(get.mock.calls[0][0]).toEqual({
-                            channel: 'full_trajectory_foo',
-                        });
-                        done();
-                    });
-                });
-                test('using id and generalizationLevel param', (done) => {
-                    api.getFullTrajectory('foo', mode, 5).then(() => {
-                        expect(get.mock.calls.length).toBe(1);
-                        expect(get.mock.calls[0][0]).toEqual({
-                            channel: 'full_trajectory_foo_gen5',
-                        });
-                        done();
-                    });
-                });
-            });
-        });
-        describe('using schematic mode ', () => {
-            test('using id', (done) => {
-                api.getFullTrajectory('foo', RealtimeModes.SCHEMATIC).then(() => {
-                    expect(get.mock.calls.length).toBe(1);
-                    expect(get.mock.calls[0][0]).toEqual({
-                        channel: 'full_trajectory_schematic_foo',
-                    });
-                    done();
-                });
-            });
-            test("doesn't use generalizationLevel param", (done) => {
-                api.getFullTrajectory('foo', RealtimeModes.SCHEMATIC, 10).then(() => {
-                    expect(get.mock.calls.length).toBe(1);
-                    expect(get.mock.calls[0][0]).toEqual({
-                        channel: 'full_trajectory_schematic_foo',
-                    });
-                    done();
-                });
-            });
-        });
-    });
-});

package/api/RoutingAPI.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=RoutingAPI.test.d.ts.map

package/api/RoutingAPI.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"RoutingAPI.test.d.ts","sourceRoot":"","sources":["../../src/api/RoutingAPI.test.js"],"names":[],"mappings":""}

package/api/RoutingAPI.test.js

@@ -1,29 +0,0 @@
-import fetch from 'jest-fetch-mock';
-import RoutingAPI from './RoutingAPI';
-let api;
-describe('RoutingAPI', () => {
-    beforeEach(() => {
-        global.fetch = fetch;
-        fetch.resetMocks();
-        api = new RoutingAPI({ apiKey: 'apiKey' });
-    });
-    describe('#route', () => {
-        test('should success', (done) => {
-            fetch.mockResponseOnce(JSON.stringify(global.fetchRouteResponse));
-            return api
-                .route({
-                mot: 'bus',
-                via: '47.3739194713294,8.538274823394632|47.37595378493421,8.537490375951839',
-            })
-                .then((featureCollection) => {
-                // Correct url
-                expect(fetch.mock.calls[0][0]).toEqual('https://api.geops.io/routing/v1/?key=apiKey&mot=bus&via=47.3739194713294%2C8.538274823394632%7C47.37595378493421%2C8.537490375951839');
-                // Correct search result (for bus mot)
-                expect(featureCollection.features[0].geometry.type).toEqual('LineString');
-                expect(featureCollection.features[0].properties.lines).toBeDefined();
-                expect(featureCollection.features[0].properties.station_to).toBeDefined();
-                done();
-            });
-        });
-    });
-});

package/api/StopsAPI.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=StopsAPI.test.d.ts.map

package/api/StopsAPI.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"StopsAPI.test.d.ts","sourceRoot":"","sources":["../../src/api/StopsAPI.test.js"],"names":[],"mappings":""}

package/api/StopsAPI.test.js

@@ -1,26 +0,0 @@
-import fetch from 'jest-fetch-mock';
-import StopsAPI from './StopsAPI';
-let api;
-describe('StopsAPI', () => {
-    beforeEach(() => {
-        global.fetch = fetch;
-        fetch.resetMocks();
-        api = new StopsAPI({ apiKey: 'apiKey' });
-    });
-    describe('#search', () => {
-        test('should success', (done) => {
-            fetch.mockResponseOnce(JSON.stringify(global.stopsSearchResponse));
-            return api
-                .search({
-                q: 'Bern',
-            })
-                .then((featureCollection) => {
-                // Correct url
-                expect(fetch.mock.calls[0][0]).toEqual('https://api.geops.io/stops/v1/?key=apiKey&q=Bern');
-                // Correct search result
-                expect(featureCollection.features[0].properties.name).toEqual('Bern');
-                done();
-            });
-        });
-    });
-});

package/common/api/HttpAPI.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=HttpAPI.test.d.ts.map

package/common/api/HttpAPI.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"HttpAPI.test.d.ts","sourceRoot":"","sources":["../../../src/common/api/HttpAPI.test.js"],"names":[],"mappings":""}

package/common/api/HttpAPI.test.js

@@ -1,54 +0,0 @@
-import fetch from 'jest-fetch-mock';
-import API from './HttpAPI';
-let api;
-describe('HttpAPI', () => {
-    beforeEach(() => {
-        global.fetch = fetch;
-        fetch.resetMocks();
-        api = new API({ url: 'https://foo.ch', apiKey: 'apiKey' });
-    });
-    describe('#fetch', () => {
-        test('should success', () => {
-            fetch.mockResponseOnce(JSON.stringify({ foo: 'bar' }));
-            return api
-                .fetch('/path', {
-                q: 'Bern',
-                fooUndefined: undefined,
-                fooNull: null,
-                fooEmpty: '',
-            })
-                .then((response) => {
-                // Correct url
-                expect(fetch.mock.calls[0][0]).toEqual('https://foo.ch/path?key=apiKey&q=Bern&fooEmpty=');
-                // Correct search result
-                expect(response).toEqual({ foo: 'bar' });
-            });
-        });
-        describe('should display error message', () => {
-            test('reject error', (done) => {
-                fetch.mockRejectOnce(new Error('Fake error message'));
-                return api.fetch().catch((err) => {
-                    expect(err.name).toEqual('Error');
-                    expect(err.message).toEqual('Fake error message');
-                    done();
-                });
-            });
-            test('if the response is invalid json', (done) => {
-                fetch.mockResponseOnce('invalid json');
-                api.fetch().catch((err) => {
-                    expect(err.name).toEqual('FetchError');
-                    expect(err.message).toEqual('invalid json response body at  reason: Unexpected token i in JSON at position 0');
-                    done();
-                });
-            });
-            test('if the response contains an error message', (done) => {
-                fetch.mockResponseOnce('{"error":"foo2"}');
-                api.fetch().catch((err) => {
-                    expect(err.name).toEqual('Error');
-                    expect(err.message).toEqual('foo2');
-                    done();
-                });
-            });
-        });
-    });
-});

package/common/api/WebSocketAPI.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=WebSocketAPI.test.d.ts.map

package/common/api/WebSocketAPI.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"WebSocketAPI.test.d.ts","sourceRoot":"","sources":["../../../src/common/api/WebSocketAPI.test.js"],"names":[],"mappings":""}