mobility-toolbox-js 2.0.0-beta.8 → 2.0.1-beta.13

package/common/utils/createTrackerFilters.js

@@ -0,0 +1,56 @@
+const createFilters = (line, route, operator, regexLine) => {
+  const filterList = [];
+  if (!line && !route && !operator && !regexLine) {
+    return null;
+  }
+  if (regexLine) {
+    const regexLineList = typeof regexLine === "string" ? [regexLine] : regexLine;
+    const lineFilter = (item) => {
+      const name = item.properties.name || item.properties.line && item.properties.line.name || "";
+      if (!name) {
+        return false;
+      }
+      return regexLineList.some((regexStr) => new RegExp(regexStr, "i").test(name));
+    };
+    filterList.push(lineFilter);
+  }
+  if (line) {
+    const lineFiltersList = typeof line === "string" ? line.split(",") : line;
+    const lineList = lineFiltersList.map((l) => l.replace(/\s+/g, "").toUpperCase());
+    const lineFilter = (item) => {
+      const { line: linee, name } = item.properties;
+      const lineName = (name || linee && linee.name || "").toUpperCase();
+      if (!lineName) {
+        return false;
+      }
+      return lineList.includes(lineName);
+    };
+    filterList.push(lineFilter);
+  }
+  if (route) {
+    const routes = typeof route === "string" ? route.split(",") : route;
+    const routeList = routes.map((item) => parseInt(item, 10));
+    const routeFilter = (item) => {
+      const routeId = parseInt(item.properties.routeIdentifier.split(".")[0], 10);
+      return routeList.includes(routeId);
+    };
+    filterList.push(routeFilter);
+  }
+  if (operator) {
+    const operatorList = typeof operator === "string" ? [operator] : operator;
+    const operatorFilter = (item) => operatorList.some((op) => new RegExp(op, "i").test(item.properties.operator));
+    filterList.push(operatorFilter);
+  }
+  if (!filterList.length) {
+    return null;
+  }
+  return (t) => {
+    for (let i = 0; i < filterList.length; i += 1) {
+      if (!filterList[i](t)) {
+        return false;
+      }
+    }
+    return true;
+  };
+};
+export default createFilters;

package/common/utils/createTrackerFilters.test.js

@@ -0,0 +1,79 @@
+import createTrackerFilters from "./createTrackerFilters";
+const u1 = {
+  properties: {
+    routeIdentifier: "001.000827.004:7",
+    operator: "FoO",
+    line: {
+      name: "U1"
+    }
+  }
+};
+const ireta = {
+  properties: {
+    routeIdentifier: "0022.000827.004:7",
+    operator: "BAR",
+    line: {
+      name: "IRETA"
+    }
+  }
+};
+const arb = {
+  properties: {
+    routeIdentifier: "00333.000827.004:7",
+    operator: "qux",
+    line: {
+      name: "ARB"
+    }
+  }
+};
+const trajectories = [u1, ireta, arb];
+describe("#createTrackerFilter()", () => {
+  test("returns null", () => {
+    const filterFunc = createTrackerFilters();
+    expect(filterFunc).toBe(null);
+  });
+  describe("using line", () => {
+    test("as string", () => {
+      const filterFunc = createTrackerFilters("u1,foo");
+      expect(trajectories.filter(filterFunc)).toEqual([u1]);
+    });
+    test("as array of string", () => {
+      const filterFunc = createTrackerFilters(["u1", "foo", "IRETA"]);
+      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
+    });
+  });
+  describe("using route identifier", () => {
+    test("as string", () => {
+      const filterFunc = createTrackerFilters(null, "1,foo");
+      expect(trajectories.filter(filterFunc)).toEqual([u1]);
+    });
+    test("as array of string", () => {
+      const filterFunc = createTrackerFilters(null, ["22", "foo", "1"]);
+      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
+    });
+  });
+  describe("using operator", () => {
+    test("as string", () => {
+      const filterFunc = createTrackerFilters(null, null, "foo");
+      expect(trajectories.filter(filterFunc)).toEqual([u1]);
+    });
+    test("as array of string", () => {
+      const filterFunc = createTrackerFilters(null, null, ["bar", "foo", "1"]);
+      expect(trajectories.filter(filterFunc)).toEqual([u1, ireta]);
+    });
+  });
+  describe("using regexLine", () => {
+    test("as string", () => {
+      const filterFunc = createTrackerFilters(null, null, null, "^(S|R$|RE|PE|D|IRE|RB|TER)");
+      expect(trajectories.filter(filterFunc)).toEqual([ireta]);
+    });
+    test("as array of string", () => {
+      const filterFunc = createTrackerFilters(null, null, null, [
+        "^IR",
+        "^ARB$",
+        "foo"
+      ]);
+      expect(trajectories.filter(filterFunc)).toEqual([ireta, arb]);
+    });
+  });
+});

package/{src/common → common}/utils/getMapboxMapCopyrights.js

@@ -1,32 +1,19 @@
-import removeDuplicate from './removeDuplicate';
-
-/**
- * Return the copyright a Mapbox map.
- * @param {mapboxgl.Map} map A Mapbox map
- * @ignore
- */
+import removeDuplicate from "./removeDuplicate";
 const getMapboxMapCopyrights = (map) => {
   if (!map || !map.style) {
     return [];
   }
   const { sourceCaches } = map.style;
   let copyrights = [];
-
   Object.values(sourceCaches).forEach((sourceCache) => {
     if (sourceCache.used) {
       const source = sourceCache.getSource();
-      const attribution =
-        source.attribution || (source.options && source.options.attribution);
-
+      const attribution = source.attribution || source.options && source.options.attribution;
       if (attribution) {
-        copyrights = copyrights.concat(
-          attribution.replace(/&copy;/g, '©').split(/(<a.*?<\/a>)/),
-        );
+        copyrights = copyrights.concat(attribution.replace(/&copy;/g, "\xA9").split(/(<a.*?<\/a>)/));
       }
     }
   });
-
   return removeDuplicate(copyrights);
 };
-
 export default getMapboxMapCopyrights;

package/common/utils/getMapboxMapCopyrights.test.js

@@ -0,0 +1,40 @@
+import getMapboxMapCopyrights from "./getMapboxMapCopyrights";
+describe("getMapboxMapCopyrights()", () => {
+  test("returns an empty array if map is not defined", () => {
+    expect(getMapboxMapCopyrights().length).toBe(0);
+  });
+  test("returns an empty array if map.style is not defined", () => {
+    expect(getMapboxMapCopyrights({}).length).toBe(0);
+  });
+  test("returns non depluicated copyrights in an array", () => {
+    expect(getMapboxMapCopyrights({
+      style: {
+        sourceCaches: {
+          used: {
+            used: true,
+            getSource() {
+              return {
+                attribution: '<a href="https://www.openmaptiles.org/" target="_blank">\xA9 OpenMapTiles</a> <a href="https://www.openstreetmap.org/about/" target="_blank">&copy; OpenStreetMap contributors</a>'
+              };
+            }
+          },
+          "not used": {
+            used: false
+          },
+          "also used": {
+            used: true,
+            getSource() {
+              return {
+                attribution: '<a href="https://www.openmaptiles.org/" target="_blank">&copy; OpenMapTiles</a> <a href="https://www.imagico.de/" target="_blank">&copy; imagico</a>'
+              };
+            }
+          }
+        }
+      }
+    })).toEqual([
+      '<a href="https://www.openmaptiles.org/" target="_blank">\xA9 OpenMapTiles</a>',
+      '<a href="https://www.openstreetmap.org/about/" target="_blank">\xA9 OpenStreetMap contributors</a>',
+      '<a href="https://www.imagico.de/" target="_blank">\xA9 imagico</a>'
+    ]);
+  });
+});

package/{src/common → common}/utils/getMapboxStyleUrl.js

@@ -1,12 +1,4 @@
-import qs from 'query-string';
-
-/**
- * Return the styleUrl with apiKey parameters set.
- * @param {string} apiKey apiKey value for the mapbox request.
- * @param {string} apiKeyName parameter name for apiKey in the mapbox request.
- * @param {string} styleUrl mapbox styleUrl value.
- * @ignore
- */
+import qs from "query-string";
 const getMapboxStyleUrl = (apiKey, apiKeyName, styleUrl) => {
   if (apiKey === false) {
     return styleUrl;
@@ -16,7 +8,6 @@ const getMapboxStyleUrl = (apiKey, apiKeyName, styleUrl) => {
     return styleUrl;
   }
   if (!apiKey) {
-    // eslint-disable-next-line no-console
     console.warn(`No apiKey is defined for request to ${styleUrl}`);
     return null;
   }
@@ -24,9 +15,8 @@ const getMapboxStyleUrl = (apiKey, apiKeyName, styleUrl) => {
     ...parsedStyle,
     query: {
       ...parsedStyle.query,
-      [apiKeyName]: apiKey,
-    },
+      [apiKeyName]: apiKey
+    }
   });
 };
-
 export default getMapboxStyleUrl;

package/{src/common → common}/utils/getVehiclePosition.js

@@ -1,23 +1,12 @@
-import GeomType from 'ol/geom/GeometryType';
-
-/**
- * Interpolate or not the vehicle position from a trajectory at a specific date.
- *
- * @param {number} now Current date to interpolate a position with. In ms.
- * @param {TralisTrajectory} trajectory The trajectory to interpolate.
- * @param {boolean} noInterpolate If true, the vehicle position is not interpolated on each render but only once.
- * @returns
- */
+import GeomType from "ol/geom/GeometryType";
 const getVehiclePosition = (now, trajectory, noInterpolate) => {
   const {
     time_intervals: timeIntervals,
     olGeometry: geometry,
-    coordinate,
+    coordinate
   } = trajectory.properties;
-
   let coord;
   let rotation;
-
   if (noInterpolate && coordinate) {
     coord = coordinate;
   } else if (geometry.getType() === GeomType.POINT) {
@@ -26,30 +15,17 @@ const getVehiclePosition = (now, trajectory, noInterpolate) => {
     const intervals = timeIntervals || [[]];
     const firstInterval = intervals[0];
     const lastInterval = intervals[intervals.length - 1];
-
-    // Between the last time interval of a trajectory event and the beginning
-    // of the new trajectory event, there is few seconds, can be 6 to 30
-    // seconds (that's why the vehicle jumps sometimes).
-    // So we make the choice here to display the last (or the first) position
-    // of an trajectory event instead of removing them, if the current date is
-    // outside the time intervals we display the vehicle at the last (or first) position known.
     if (now < firstInterval[0]) {
-      // Display first position known.
       [, , rotation] = firstInterval;
       coord = geometry.getFirstCoordinate();
     } else if (now > lastInterval[0]) {
-      // Display last position known.
       [, , rotation] = lastInterval;
       coord = geometry.getLastCoordinate();
     } else {
-      // Interpolate position using time intervals.
       for (let j = 0; j < intervals.length - 1; j += 1) {
-        // Rotation only available in tralis layer.
         const [start, startFrac] = intervals[j];
         const [end, endFrac] = intervals[j + 1];
-
         if (start <= now && now <= end) {
-          // interpolate position inside the time interval.
           const timeFrac = Math.min((now - start) / (end - start), 1);
           const geomFrac = timeFrac * (endFrac - startFrac) + startFrac;
           coord = geometry.getCoordinateAt(geomFrac);
@@ -59,14 +35,8 @@ const getVehiclePosition = (now, trajectory, noInterpolate) => {
       }
     }
   } else {
-    // eslint-disable-next-line no-console
-    console.error(
-      'This geometry type is not supported. Only Point or LineString are. Current geometry: ',
-      geometry,
-    );
+    console.error("This geometry type is not supported. Only Point or LineString are. Current geometry: ", geometry);
   }
-
   return { coord, rotation };
 };
-
 export default getVehiclePosition;

package/common/utils/index.js

@@ -0,0 +1,5 @@
+export { default as getMapboxStyleUrl } from "./getMapboxStyleUrl";
+export { default as getMapboxMapCopyrights } from "./getMapboxMapCopyrights";
+export { default as removeDuplicate } from "./removeDuplicate";
+export * from "./timeUtils";
+export { default as sortByDelay } from "./sortByDelay";

package/common/utils/removeDuplicate.js

@@ -0,0 +1,8 @@
+const removeDuplicate = (array) => {
+  const arrWithoutEmptyValues = array.filter((val) => val !== void 0 && val !== null && val.trim && val.trim());
+  const lowerCasesValues = arrWithoutEmptyValues.map((str) => str.toLowerCase());
+  const uniqueLowerCaseValues = [...new Set(lowerCasesValues)];
+  const uniqueValues = uniqueLowerCaseValues.map((uniqueStr) => arrWithoutEmptyValues.find((str) => str.toLowerCase() === uniqueStr));
+  return uniqueValues;
+};
+export default removeDuplicate;

package/common/utils/removeDuplicate.test.js

@@ -0,0 +1,19 @@
+import removeDuplicate from "./removeDuplicate";
+describe("removeDuplicate()", () => {
+  test("removes duplicates", () => {
+    expect(removeDuplicate([
+      "a",
+      " ",
+      "   ",
+      "b",
+      "a",
+      void 0,
+      null,
+      "A",
+      0,
+      "c",
+      "b",
+      "B"
+    ])).toEqual(["a", "b", "c"]);
+  });
+});

package/{src/common → common}/utils/sortByDelay.js

@@ -1,23 +1,18 @@
 const sortByDelay = (traj1, traj2) => {
   const props1 = traj1.properties;
   const props2 = traj2.properties;
-
   if (props1.delay === null && props2.delay !== null) {
     return 1;
   }
   if (props2.delay === null && props1.delay !== null) {
     return -1;
   }
-
-  // We put cancelled train inbetween green and yellow trains
-  // >=180000ms corresponds to yellow train
   if (props1.cancelled && !props2.cancelled) {
-    return props2.delay < 180000 ? -1 : 1;
+    return props2.delay < 18e4 ? -1 : 1;
   }
   if (props2.cancelled && !props1.cancelled) {
-    return props1.delay < 180000 ? 1 : -1;
+    return props1.delay < 18e4 ? 1 : -1;
   }
   return props2.delay - props1.delay;
 };
-
 export default sortByDelay;

package/common/utils/timeUtils.js

@@ -0,0 +1,20 @@
+export const getUTCDateString = (now = new Date()) => {
+  let month = (now.getUTCMonth() + 1).toString();
+  month = month.length === 1 ? `0${month}` : month;
+  let day = now.getUTCDate().toString();
+  day = day.length === 1 ? `0${day}` : day;
+  return [now.getUTCFullYear(), month, day].join("");
+};
+export const getUTCTimeString = (date) => [
+  date.getUTCHours(),
+  date.getUTCMinutes(),
+  `${date.getUTCSeconds()}.${date.getUTCMilliseconds()}`
+].join(":");
+export const pad = (integer) => integer < 10 ? `0${integer}` : integer;
+export const getHoursAndMinutes = (timeInMs) => {
+  if (!timeInMs || timeInMs <= 0) {
+    return "";
+  }
+  const date = new Date(timeInMs);
+  return `${pad(date.getHours())}:${pad(date.getMinutes())}`;
+};

package/common/utils/timeUtils.test.js

@@ -0,0 +1,10 @@
+import { getUTCDateString, getUTCTimeString } from "./timeUtils";
+describe("timeUtils", () => {
+  test("getUTCDateString should be correct.", () => {
+    expect(getUTCDateString(new Date(2020, 5, 30))).toBe("20200630");
+    expect(getUTCDateString(new Date("January 1, 2021 00:15:30 GMT+2:00"))).toBe("20201231");
+  });
+  test("getUTCTimeString should be correct.", () => {
+    expect(getUTCTimeString(new Date(2020, 5, 30, 11, 5, 1, 123))).toBe("11:5:1.123");
+  });
+});

package/index.js

@@ -0,0 +1,8 @@
+import * as ol from "./ol";
+import * as mapbox from "./mapbox";
+export * as ol from "./ol";
+export * as mapbox from "./mapbox";
+export default {
+  ol,
+  mapbox
+};

package/mapbox/controls/CopyrightControl.js

@@ -0,0 +1,29 @@
+import Control from "../../common/controls/Control";
+import mixin from "../../common/mixins/CopyrightMixin";
+import { getMapboxMapCopyrights } from "../../common/utils";
+class CopyrightControl extends mixin(Control) {
+  constructor(options) {
+    super(options);
+    this.render = this.render.bind(this);
+  }
+  activate() {
+    super.activate();
+    if (this.map) {
+      this.map.on("sourcedata", this.render);
+      this.map.on("styledata", this.render);
+      this.map.on("idle", this.render);
+    }
+  }
+  deactivate() {
+    if (this.map) {
+      this.map.off("sourcedata", this.render);
+      this.map.off("styledata", this.render);
+      this.map.off("idle", this.render);
+    }
+    super.deactivate();
+  }
+  getCopyrights() {
+    return getMapboxMapCopyrights(this.map);
+  }
+}
+export default CopyrightControl;

package/mapbox/controls/index.js

@@ -0,0 +1 @@
+export { default as CopyrightControl } from "./CopyrightControl";

package/mapbox/index.js

@@ -0,0 +1,4 @@
+export * from "../api";
+export * from "../common";
+export * from "./controls";
+export * from "./layers";

package/mapbox/layers/Layer.js

@@ -0,0 +1,57 @@
+import { unByKey } from "ol/Observable";
+import { transformExtent } from "ol/proj";
+import LayerCommon from "../../common/layers/Layer";
+class Layer extends LayerCommon {
+  attachToMap(map) {
+    super.attachToMap(map);
+    if (!this.map) {
+      return;
+    }
+    if (this.isClickActive || this.isHoverActive) {
+      this.toggleVisibleListeners();
+      this.onChangeVisibleKey = this.on("change:visible", this.toggleVisibleListeners);
+    }
+  }
+  detachFromMap(map) {
+    if (this.map) {
+      this.map.off("mousemove", this.onUserMoveCallback);
+      this.map.off("click", this.onUserClickCallback);
+      unByKey(this.onChangeVisibleKey);
+    }
+    super.detachFromMap(map);
+  }
+  onUserClickCallback(evt) {
+    super.onUserClickCallback({ coordinate: evt.lngLat.toArray(), ...evt });
+  }
+  onUserMoveCallback(evt) {
+    super.onUserMoveCallback({ coordinate: evt.lngLat.toArray(), ...evt });
+  }
+  toggleVisibleListeners() {
+    if (this.visible) {
+      if (this.isClickActive) {
+        this.map.on("click", this.onUserClickCallback);
+      }
+      if (this.isHoverActive) {
+        this.map.on("mousemove", this.onUserMoveCallback);
+      }
+    } else {
+      if (this.isClickActive) {
+        this.map.off("click", this.onUserClickCallback);
+      }
+      if (this.isHoverActive) {
+        this.map.off("mousemove", this.onUserMoveCallback);
+      }
+    }
+  }
+  getMercatorExtent() {
+    const bounds = this.map.getBounds().toArray();
+    return transformExtent([...bounds[0], ...bounds[1]], "EPSG:4326", "EPSG:3857");
+  }
+  getOlZoom() {
+    return this.map.getZoom() + 1;
+  }
+  clone(newOptions) {
+    return new Layer({ ...this.options, ...newOptions });
+  }
+}
+export default Layer;