mobility-toolbox-js 2.0.0-beta.32 → 2.0.0-beta.33

package/api/RealtimeAPI.js

@@ -1,357 +0,0 @@
-import WebSocketAPI from "../common/api/WebSocketAPI";
-import cleanStopTime from "../common/utils/cleanStopTime";
-import getModeSuffix from "../common/utils/getRealtimeModeSuffix";
-import compareDepartures from "../common/utils/compareDepartures";
-export const RealtimeModes = {
-  RAW: "raw",
-  TOPOGRAPHIC: "topographic",
-  SCHEMATIC: "schematic"
-};
-class RealtimeAPI {
-  constructor(options = {}) {
-    this.defineProperties(options);
-    this.subscribedStationUic = null;
-    this.departureUpdateTimeout = null;
-    this.maxDepartureAge = 30;
-    this.extraGeoms = {};
-    this.prefix = options.prefix || "";
-    this.onOpen = this.onOpen.bind(this);
-  }
-  defineProperties(options) {
-    let opt = options;
-    if (typeof options === "string") {
-      opt = { url: options };
-    }
-    const { apiKey } = opt;
-    let { url, projection, bbox, buffer = [100, 100] } = opt;
-    const wsApi = new WebSocketAPI();
-    if (apiKey) {
-      url = `${url || "wss://api.geops.io/tracker-ws/v1/"}?key=${apiKey}`;
-    }
-    Object.defineProperties(this, {
-      url: {
-        get: () => url,
-        set: (newUrl) => {
-          url = newUrl;
-          this.open();
-        }
-      },
-      projection: {
-        get: () => projection,
-        set: (newProjection) => {
-          if (newProjection !== projection) {
-            projection = newProjection;
-            if (this.wsApi) {
-              this.wsApi.send(`PROJECTION ${projection}`);
-            }
-          }
-        }
-      },
-      bbox: {
-        get: () => bbox,
-        set: (newBbox) => {
-          if (JSON.stringify(newBbox) !== JSON.stringify(bbox)) {
-            bbox = newBbox;
-            if (this.wsApi) {
-              this.wsApi.send(`BBOX ${bbox.join(" ")}`);
-            }
-          }
-        }
-      },
-      buffer: {
-        get: () => buffer,
-        set: (newBuffer) => {
-          if (JSON.stringify(newBuffer) !== JSON.stringify(buffer)) {
-            buffer = newBuffer;
-            if (this.wsApi) {
-              this.wsApi.send(`BUFFER ${buffer.join(" ")}`);
-            }
-          }
-        }
-      },
-      wsApi: {
-        value: wsApi,
-        writable: true
-      },
-      pingIntervalMs: {
-        value: options.pingIntervalMs || 1e4,
-        writable: true
-      },
-      reconnectTimeoutMs: {
-        value: options.pingIntervalMs || 100,
-        writable: true
-      }
-    });
-  }
-  open() {
-    this.close();
-    this.wsApi.connect(this.url, this.onOpen);
-    this.wsApi.websocket.onclose = () => {
-      this.onClose();
-    };
-  }
-  close() {
-    this.wsApi.close();
-  }
-  reset() {
-    this.wsApi.send("RESET");
-  }
-  onOpen() {
-    if (this.projection) {
-      this.wsApi.send(`PROJECTION ${this.projection}`);
-    }
-    if (this.bbox) {
-      this.wsApi.send(`BBOX ${this.bbox.join(" ")}`);
-    }
-    if (this.buffer) {
-      this.wsApi.send(`BUFFER ${this.buffer.join(" ")}`);
-    }
-    if (this.pingIntervalMs) {
-      window.clearInterval(this.pingInterval);
-      this.pingInterval = setInterval(() => {
-        this.wsApi.send("PING");
-      }, this.pingIntervalMs);
-    }
-  }
-  onClose() {
-    window.clearTimeout(this.pingInterval);
-    window.clearTimeout(this.reconnectTimeout);
-    if (this.reconnectTimeoutMs) {
-      this.reconnectTimeout = window.setTimeout(() => this.open(), this.reconnectTimeoutMs);
-    }
-  }
-  subscribe(channel, onSuccess, onError, quiet = false) {
-    this.wsApi.subscribe({ channel }, onSuccess, onError, quiet);
-  }
-  unsubscribe(channel, suffix, cb) {
-    this.wsApi.unsubscribe(`${channel}${getModeSuffix(RealtimeModes.SCHEMATIC, RealtimeModes)}${suffix}`, cb);
-    this.wsApi.unsubscribe(`${channel}${getModeSuffix(RealtimeModes.TOPOGRAPHIC, RealtimeModes)}${suffix || ""}`, cb);
-  }
-  filterDepartures(depObject, sortByMinArrivalTime = false) {
-    const departures = Object.keys(depObject).map((k) => depObject[k]);
-    departures.sort((a, b) => compareDepartures(a, b, sortByMinArrivalTime));
-    let future = new Date();
-    future.setMinutes(future.getMinutes() + this.maxDepartureAge);
-    future = future.getTime();
-    let past = new Date();
-    past.setMinutes(past.getMinutes() - this.maxDepartureAge);
-    past = past.getTime();
-    const departureArray = [];
-    const platformsBoarding = [];
-    let previousDeparture = null;
-    for (let i = departures.length - 1; i >= 0; i -= 1) {
-      const d = departures[i];
-      const t = new Date(d.time).getTime();
-      if (t > past && t < future) {
-        if (d.state === "BOARDING") {
-          if (platformsBoarding.indexOf(d.platform) === -1) {
-            platformsBoarding.push(d.platform);
-          } else {
-            d.state = "HIDDEN";
-          }
-        }
-        if (previousDeparture && d.to[0] === previousDeparture.to[0] && Math.abs(t - previousDeparture.time) < 1e3 && d.line.name === previousDeparture.line.name) {
-          d.state = "HIDDEN";
-        }
-        if (/(STOP_CANCELLED|JOURNEY_CANCELLED)/.test(d.state)) {
-          d.cancelled = true;
-        }
-        previousDeparture = d;
-        previousDeparture.time = t;
-        departureArray.unshift(d);
-      }
-    }
-    return departureArray;
-  }
-  subscribeDepartures(stationId, sortByMinArrivalTime, onMessage) {
-    window.clearTimeout(this.departureUpdateTimeout);
-    this.unsubscribeDepartures();
-    this.subscribedStationUic = stationId;
-    const channel = stationId ? `timetable_${stationId}` : null;
-    const departureObject = {};
-    this.subscribe(channel, (data) => {
-      if (data.source === channel) {
-        const content = data.content || {};
-        const tDiff = new Date(content.timestamp).getTime() - Date.now();
-        content.timediff = tDiff;
-        departureObject[content.call_id] = content;
-        window.clearTimeout(this.departureUpdateTimeout);
-        this.departureUpdateTimeout = window.setTimeout(() => {
-          const departures = this.filterDepartures(departureObject, sortByMinArrivalTime || false);
-          onMessage(departures);
-        }, 100);
-      }
-    }, () => {
-      onMessage([]);
-    });
-  }
-  unsubscribeDepartures(cb) {
-    if (this.subscribedStationUic) {
-      this.unsubscribe(`timetable_${this.subscribedStationUic}`, "", cb);
-      this.subscribedStationUic = null;
-    }
-  }
-  subscribeDisruptions(onMessage) {
-    this.subscribe(`${this.prefix}newsticker`, (data) => {
-      onMessage(data.content);
-    });
-  }
-  unsubscribeDisruptions(cb) {
-    this.unsubscribe(`${this.prefix}newsticker`, "", cb);
-  }
-  getStation(uic, mode) {
-    const params = {
-      channel: `station${getModeSuffix(mode, RealtimeModes)}`,
-      args: uic
-    };
-    return new Promise((resolve, reject) => {
-      this.wsApi.get(params, (data) => {
-        if (data.content) {
-          resolve(data.content);
-        } else {
-          reject();
-        }
-      });
-    });
-  }
-  getStations(mode) {
-    const stations = [];
-    const params = {
-      channel: `station${getModeSuffix(mode, RealtimeModes)}`
-    };
-    window.clearTimeout(this.stationUpdateTimeout);
-    return new Promise((resolve, reject) => {
-      this.wsApi.get(params, (data) => {
-        if (data.content) {
-          stations.push(data.content);
-          window.clearTimeout(this.stationUpdateTimeout);
-          this.stationUpdateTimeout = window.setTimeout(() => {
-            resolve(stations);
-          }, 50);
-        } else {
-          reject(data.content);
-        }
-      });
-    });
-  }
-  subscribeStations(mode, onMessage) {
-    this.unsubscribeStations();
-    this.subscribe(`station${getModeSuffix(mode, RealtimeModes)}`, (data) => {
-      if (data.content) {
-        onMessage(data.content);
-      }
-    });
-  }
-  unsubscribeStations(cb) {
-    window.clearTimeout(this.stationUpdateTimeout);
-    this.unsubscribe("station", "", cb);
-  }
-  subscribeExtraGeoms(onMessage) {
-    this.subscribe("extra_geoms", (data) => {
-      const extraGeom = data.content;
-      if (extraGeom) {
-        const { ref } = extraGeom.properties;
-        if (extraGeom.type === "Feature") {
-          this.extraGeoms[ref] = extraGeom;
-        } else {
-          delete this.extraGeoms[ref];
-        }
-        onMessage(Object.keys(this.extraGeoms).map((key) => this.extraGeoms[key]));
-      }
-    });
-  }
-  unsubscribeExtraGeoms(cb) {
-    this.unsubscribe("extra_geoms", "", cb);
-  }
-  subscribeTrajectory(mode, onMessage, quiet = false) {
-    this.unsubscribeTrajectory(onMessage);
-    this.subscribe(`trajectory${getModeSuffix(mode, RealtimeModes)}`, onMessage, null, quiet);
-  }
-  unsubscribeTrajectory(cb) {
-    this.unsubscribe(`trajectory`, "", cb);
-  }
-  subscribeDeletedVehicles(mode, onMessage, quiet = false) {
-    this.unsubscribeDeletedVehicles(onMessage);
-    this.subscribe(`deleted_vehicles${getModeSuffix(mode, RealtimeModes)}`, onMessage, null, quiet);
-  }
-  unsubscribeDeletedVehicles(cb) {
-    this.unsubscribe("deleted_vehicles", "", cb);
-  }
-  getFullTrajectory(id, mode, generalizationLevel) {
-    const channel = [`full_trajectory${getModeSuffix(mode, RealtimeModes)}`];
-    if (id) {
-      channel.push(id);
-    }
-    if ((!mode || mode === RealtimeModes.TOPOGRAPHIC) && generalizationLevel) {
-      channel.push(`gen${generalizationLevel}`);
-    }
-    const params = {
-      channel: channel.join("_")
-    };
-    return new Promise((resolve) => {
-      this.wsApi.get(params, (data) => {
-        if (data.content) {
-          resolve(data.content);
-        }
-      });
-    });
-  }
-  getFullTrajectories(ids, mode, generalizationLevel) {
-    const promises = ids.map((id) => this.getFullTrajectory(id, mode, generalizationLevel));
-    return Promise.all(promises);
-  }
-  subscribeFullTrajectory(id, mode) {
-    this.unsubscribeFullTrajectory(id);
-    this.subscribe(`full_trajectory${getModeSuffix(mode, RealtimeModes)}_${id}`, (data) => {
-      console.log("subscribe full_trajectory", data);
-    }, (err) => {
-      console.log("subscribe full_trajectory error", err);
-    });
-  }
-  unsubscribeFullTrajectory(id, cb) {
-    this.unsubscribe("full_trajectory", `_${id}`, cb);
-  }
-  getStopSequence(id) {
-    const params = {
-      channel: `stopsequence_${id}`
-    };
-    return new Promise((resolve, reject) => {
-      this.wsApi.get(params, (data) => {
-        if (data.content && data.content.length) {
-          const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
-          resolve(content);
-        }
-        resolve([]);
-      }, (err) => {
-        reject(err);
-      });
-    });
-  }
-  getStopSequences(ids) {
-    const promises = ids.map((id) => this.getStopSequence(id));
-    return Promise.all(promises);
-  }
-  subscribeStopSequence(id, onMessage) {
-    window.clearTimeout(this.fullTrajectoryUpdateTimeout);
-    this.unsubscribeStopSequence(id);
-    this.subscribe(`stopsequence_${id}`, (data) => {
-      if (data.content && data.content.length) {
-        const content = data.content.map((stopSequence) => cleanStopTime(stopSequence));
-        onMessage(content);
-      }
-    }, (err) => {
-      console.log("subscribe stopsequence error", err);
-    });
-  }
-  unsubscribeStopSequence(id, cb) {
-    this.unsubscribe(`stopsequence`, `_${id}`, cb);
-  }
-  subscribeHealthCheck(onMessage) {
-    this.unsubscribeHealthCheck();
-    this.subscribe("healthcheck", onMessage);
-  }
-  unsubscribeHealthCheck() {
-    this.unsubscribe("healthcheck");
-  }
-}
-export default RealtimeAPI;

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.js

@@ -1,15 +0,0 @@
-import HttpAPI from "../common/api/HttpAPI";
-class RoutingAPI extends HttpAPI {
-  constructor(options = {}) {
-    super({
-      url: "https://api.geops.io/routing/v1/",
-      ...options
-    });
-  }
-  route(params, abortController = new AbortController()) {
-    return this.fetch("", params, {
-      signal: abortController.signal
-    });
-  }
-}
-export default RoutingAPI;

package/api/RoutingAPI.test.js

@@ -1,25 +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) => {
-        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");
-        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.js

@@ -1,12 +0,0 @@
-import HttpAPI from "../common/api/HttpAPI";
-class StopsAPI extends HttpAPI {
-  constructor(options = {}) {
-    super({ url: "https://api.geops.io/stops/v1/", ...options });
-  }
-  search(params, abortController = {}) {
-    return this.fetch("", params, {
-      signal: abortController.signal
-    });
-  }
-}
-export default StopsAPI;

package/api/StopsAPI.test.js

@@ -1,22 +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) => {
-        expect(fetch.mock.calls[0][0]).toEqual("https://api.geops.io/stops/v1/?key=apiKey&q=Bern");
-        expect(featureCollection.features[0].properties.name).toEqual("Bern");
-        done();
-      });
-    });
-  });
-});

package/api/index.js

@@ -1,3 +0,0 @@
-export { default as RoutingAPI } from "./RoutingAPI";
-export { default as StopsAPI } from "./StopsAPI";
-export { default as RealtimeAPI, RealtimeModes } from "./RealtimeAPI";

package/common/api/HttpAPI.js

@@ -1,32 +0,0 @@
-import BaseObject from "ol/Object";
-import getUrlWithParams from "../utils/getUrlWithParams";
-class HttpAPI extends BaseObject {
-  constructor(options = {}) {
-    super();
-    this.url = options.url;
-    this.apiKey = options.apiKey;
-  }
-  fetch(path, params, config) {
-    if (!this.apiKey && !/key=/.test(this.url)) {
-      return Promise.reject(new Error(`No apiKey defined for request to ${this.url}`));
-    }
-    const searchParams = params || {};
-    const url = getUrlWithParams(`${this.url}${path || ""}`, {
-      key: this.apiKey,
-      ...searchParams
-    });
-    return fetch(url.toString(), config).then((response) => {
-      try {
-        return response.json().then((data) => {
-          if (data.error) {
-            throw new Error(data.error);
-          }
-          return data;
-        });
-      } catch (err) {
-        return Promise.reject(new Error(err));
-      }
-    });
-  }
-}
-export default HttpAPI;

package/common/api/HttpAPI.test.js

@@ -1,50 +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: void 0,
-        fooNull: null,
-        fooEmpty: ""
-      }).then((response) => {
-        expect(fetch.mock.calls[0][0]).toEqual("https://foo.ch/path?key=apiKey&q=Bern&fooEmpty=");
-        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();
-        });
-      });
-    });
-  });
-});