mobility-toolbox-js 2.0.0-beta.30 → 2.0.0-beta.34

package/common/styles/realtimeDefaultStyle.js

@@ -1,202 +1,248 @@
-import createCanvas from "../utils/createCanvas";
-const cacheDelayBg = {};
-export const getDelayBgCanvas = (origin, radius, color) => {
-  const key = `${origin}, ${radius}, ${color}`;
-  if (!cacheDelayBg[key]) {
-    const canvas = createCanvas(origin * 2, origin * 2);
-    if (canvas) {
-      const ctx = canvas.getContext("2d");
-      ctx.beginPath();
-      ctx.arc(origin, origin, radius, 0, 2 * Math.PI, false);
-      ctx.fillStyle = color;
-      ctx.filter = "blur(1px)";
-      ctx.fill();
-      cacheDelayBg[key] = canvas;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTextCanvas = exports.getCircleCanvas = exports.getDelayTextCanvas = exports.getDelayBgCanvas = void 0;
+var createCanvas_1 = require("../utils/createCanvas");
+/** @private */
+var cacheDelayBg = {};
+/**
+ * Draw circle delay background
+ *
+ * @private
+ */
+var getDelayBgCanvas = function (origin, radius, color) {
+    var key = "".concat(origin, ", ").concat(radius, ", ").concat(color);
+    if (!cacheDelayBg[key]) {
+        var canvas = (0, createCanvas_1.default)(origin * 2, origin * 2);
+        if (canvas) {
+            var ctx = canvas.getContext('2d');
+            ctx.beginPath();
+            ctx.arc(origin, origin, radius, 0, 2 * Math.PI, false);
+            ctx.fillStyle = color;
+            ctx.filter = 'blur(1px)';
+            ctx.fill();
+            cacheDelayBg[key] = canvas;
+        }
     }
-  }
-  return cacheDelayBg[key];
+    return cacheDelayBg[key];
 };
-const cacheDelayText = {};
-export const getDelayTextCanvas = (width, text, fontSize, font, delayColor, delayOutlineColor = "#000", pixelRatio = 1) => {
-  const key = `${width}, ${text}, ${font}, ${delayColor}, ${delayOutlineColor}, ${pixelRatio}`;
-  if (!cacheDelayText[key]) {
-    const canvas = createCanvas(width, fontSize + 8 * pixelRatio);
-    if (canvas) {
-      const ctx = canvas.getContext("2d");
-      ctx.textAlign = "left";
-      ctx.textBaseline = "middle";
-      ctx.font = font;
-      ctx.fillStyle = delayColor;
-      ctx.strokeStyle = delayOutlineColor;
-      ctx.lineWidth = 1.5 * pixelRatio;
-      const delayText = text;
-      ctx.strokeText(delayText, 0, fontSize);
-      ctx.fillText(delayText, 0, fontSize);
-      cacheDelayText[key] = canvas;
+exports.getDelayBgCanvas = getDelayBgCanvas;
+/** @private */
+var cacheDelayText = {};
+/**
+ * Draw delay text
+ *
+ * @private
+ */
+var getDelayTextCanvas = function (width, text, fontSize, font, delayColor, delayOutlineColor, pixelRatio) {
+    if (delayOutlineColor === void 0) { delayOutlineColor = '#000'; }
+    if (pixelRatio === void 0) { pixelRatio = 1; }
+    var key = "".concat(width, ", ").concat(text, ", ").concat(font, ", ").concat(delayColor, ", ").concat(delayOutlineColor, ", ").concat(pixelRatio);
+    if (!cacheDelayText[key]) {
+        var canvas = (0, createCanvas_1.default)(width, fontSize + 8 * pixelRatio);
+        if (canvas) {
+            var ctx = canvas.getContext('2d');
+            ctx.textAlign = 'left';
+            ctx.textBaseline = 'middle';
+            ctx.font = font;
+            ctx.fillStyle = delayColor;
+            ctx.strokeStyle = delayOutlineColor;
+            ctx.lineWidth = 1.5 * pixelRatio;
+            var delayText = text;
+            ctx.strokeText(delayText, 0, fontSize);
+            ctx.fillText(delayText, 0, fontSize);
+            cacheDelayText[key] = canvas;
+        }
     }
-  }
-  return cacheDelayText[key];
+    return cacheDelayText[key];
 };
-const cacheCircle = {};
-export const getCircleCanvas = (origin, radius, color, hasStroke, hasDash, pixelRatio) => {
-  const key = `${origin}, ${radius}, ${color}, ${hasStroke},  ${hasDash}, ${pixelRatio}`;
-  if (!cacheCircle[key]) {
-    const canvas = createCanvas(origin * 2, origin * 2);
-    if (canvas) {
-      const ctx = canvas.getContext("2d");
-      ctx.fillStyle = color;
-      if (hasStroke) {
-        ctx.lineWidth = 1 * pixelRatio;
-        ctx.strokeStyle = "#000000";
-      }
-      ctx.beginPath();
-      ctx.arc(origin, origin, radius, 0, 2 * Math.PI, false);
-      ctx.fill();
-      if (hasDash) {
-        ctx.setLineDash([5, 3]);
-      }
-      if (hasStroke) {
-        ctx.stroke();
-      }
-      cacheCircle[key] = canvas;
+exports.getDelayTextCanvas = getDelayTextCanvas;
+/** @private */
+var cacheCircle = {};
+/**
+ * Draw colored circle with black border
+ *
+ * @private
+ */
+var getCircleCanvas = function (origin, radius, color, hasStroke, hasDash, pixelRatio) {
+    var key = "".concat(origin, ", ").concat(radius, ", ").concat(color, ", ").concat(hasStroke, ",  ").concat(hasDash, ", ").concat(pixelRatio);
+    if (!cacheCircle[key]) {
+        var canvas = (0, createCanvas_1.default)(origin * 2, origin * 2);
+        if (canvas) {
+            var ctx = canvas.getContext('2d');
+            ctx.fillStyle = color;
+            if (hasStroke) {
+                ctx.lineWidth = 1 * pixelRatio;
+                ctx.strokeStyle = '#000000';
+            }
+            ctx.beginPath();
+            ctx.arc(origin, origin, radius, 0, 2 * Math.PI, false);
+            ctx.fill();
+            if (hasDash) {
+                ctx.setLineDash([5, 3]);
+            }
+            if (hasStroke) {
+                ctx.stroke();
+            }
+            cacheCircle[key] = canvas;
+        }
     }
-  }
-  return cacheCircle[key];
+    return cacheCircle[key];
 };
-const cacheText = {};
-export const getTextCanvas = (text, origin, textSize, fillColor, strokeColor, hasStroke, pixelRatio) => {
-  const key = `${text}, ${origin}, ${textSize}, ${fillColor},${strokeColor}, ${hasStroke}, ${pixelRatio}`;
-  if (!cacheText[key]) {
-    const canvas = createCanvas(origin * 2, origin * 2);
-    if (canvas) {
-      const ctx = canvas.getContext("2d");
-      if (hasStroke) {
-        ctx.save();
-        ctx.textBaseline = "middle";
-        ctx.textAlign = "center";
-        ctx.font = `bold ${textSize + 2}px Arial`;
-        ctx.strokeStyle = strokeColor;
-        ctx.strokeText(text, origin, origin);
-        ctx.restore();
-      }
-      ctx.textBaseline = "middle";
-      ctx.textAlign = "center";
-      ctx.fillStyle = fillColor;
-      ctx.font = `bold ${textSize}px Arial`;
-      ctx.strokeStyle = strokeColor;
-      ctx.strokeText(text, origin, origin);
-      ctx.fillText(text, origin, origin);
-      cacheText[key] = canvas;
+exports.getCircleCanvas = getCircleCanvas;
+/** @private */
+var cacheText = {};
+/**
+ * Draw text in the circle
+ *
+ * @private
+ */
+var getTextCanvas = function (text, origin, textSize, fillColor, strokeColor, hasStroke, pixelRatio) {
+    var key = "".concat(text, ", ").concat(origin, ", ").concat(textSize, ", ").concat(fillColor, ",").concat(strokeColor, ", ").concat(hasStroke, ", ").concat(pixelRatio);
+    if (!cacheText[key]) {
+        var canvas = (0, createCanvas_1.default)(origin * 2, origin * 2);
+        if (canvas) {
+            var ctx = canvas.getContext('2d');
+            // Draw a stroke to the text only if a provider provides realtime but we don't use it.
+            if (hasStroke) {
+                ctx.save();
+                ctx.textBaseline = 'middle';
+                ctx.textAlign = 'center';
+                ctx.font = "bold ".concat(textSize + 2, "px Arial");
+                ctx.strokeStyle = strokeColor;
+                ctx.strokeText(text, origin, origin);
+                ctx.restore();
+            }
+            // Draw a text
+            ctx.textBaseline = 'middle';
+            ctx.textAlign = 'center';
+            ctx.fillStyle = fillColor;
+            ctx.font = "bold ".concat(textSize, "px Arial");
+            ctx.strokeStyle = strokeColor;
+            ctx.strokeText(text, origin, origin);
+            ctx.fillText(text, origin, origin);
+            cacheText[key] = canvas;
+        }
     }
-  }
-  return cacheText[key];
+    return cacheText[key];
 };
-const cache = {};
-const realtimeDefaultStyle = (trajectory, viewState, options) => {
-  const {
-    hoverVehicleId,
-    selectedVehicleId,
-    useDelayStyle,
-    delayOutlineColor = "#000",
-    delayDisplay = 3e5,
-    getRadius,
-    getBgColor,
-    getDelayColor,
-    getDelayText,
-    getTextColor,
-    getTextSize
-  } = options;
-  const { zoom, pixelRatio } = viewState;
-  let { type, cancelled } = trajectory.properties;
-  const {
-    train_id: id,
-    line,
-    delay,
-    state,
-    operator_provides_realtime_journey: operatorProvidesRealtime
-  } = trajectory.properties;
-  let { name, text_color: textColor, color } = line || {};
-  cancelled = cancelled === true || state === "JOURNEY_CANCELLED";
-  if (!type) {
-    type = "Rail";
-  }
-  if (!name) {
-    name = "I";
-  }
-  if (!textColor) {
-    textColor = "#000000";
-  }
-  if (color && color[0] !== "#") {
-    color = `#${color}`;
-  }
-  if (textColor[0] !== "#") {
-    textColor = `#${textColor}`;
-  }
-  const z = Math.min(Math.floor(zoom || 1), 16);
-  const hover = hoverVehicleId && hoverVehicleId === id;
-  const selected = selectedVehicleId && selectedVehicleId === id;
-  let radius = getRadius(type, z) * pixelRatio;
-  const isDisplayStrokeAndDelay = radius >= 7 * pixelRatio;
-  if (hover || selected) {
-    radius = isDisplayStrokeAndDelay ? radius + 5 * pixelRatio : 14 * pixelRatio;
-  }
-  const mustDrawText = radius > 10 * pixelRatio;
-  let key = `${radius}${hover}${selected}${cancelled}${delay}`;
-  if (useDelayStyle) {
-    key += `${operatorProvidesRealtime}`;
-  } else {
-    key += `${type}${color}`;
-  }
-  if (mustDrawText) {
-    key += `${name}${textColor}`;
-  }
-  if (!cache[key]) {
-    if (radius === 0) {
-      cache[key] = null;
-      return null;
+exports.getTextCanvas = getTextCanvas;
+/** @private */
+var cache = {};
+/**
+ * A tracker style that take in account the delay.
+ *
+ * @param {*} trajectory The trajectory to render.
+ * @param {*} viewState The view state of the map.
+ * @param {*} options Some options to change the rendering
+ * @return a canvas
+ */
+var realtimeDefaultStyle = function (trajectory, viewState, options) {
+    var hoverVehicleId = options.hoverVehicleId, selectedVehicleId = options.selectedVehicleId, useDelayStyle = options.useDelayStyle, _a = options.delayOutlineColor, delayOutlineColor = _a === void 0 ? '#000' : _a, _b = options.delayDisplay, delayDisplay = _b === void 0 ? 300000 : _b, getRadius = options.getRadius, getBgColor = options.getBgColor, getDelayColor = options.getDelayColor, getDelayText = options.getDelayText, getTextColor = options.getTextColor, getTextSize = options.getTextSize;
+    var zoom = viewState.zoom, pixelRatio = viewState.pixelRatio;
+    var _c = trajectory.properties, type = _c.type, cancelled = _c.cancelled;
+    var _d = trajectory.properties, id = _d.train_id, line = _d.line, delay = _d.delay, state = _d.state, operatorProvidesRealtime = _d.operator_provides_realtime_journey;
+    var _e = line || {}, name = _e.name, textColor = _e.text_color, color = _e.color;
+    // In the future, the cancelled property will be removed we still managed it
+    // until the backend change is on prod.
+    cancelled = cancelled === true || state === 'JOURNEY_CANCELLED';
+    if (!type) {
+        type = 'Rail';
+    }
+    if (!name) {
+        name = 'I';
+    }
+    if (!textColor) {
+        textColor = '#000000';
+    }
+    if (color && color[0] !== '#') {
+        color = "#".concat(color);
     }
-    const margin = 1 * pixelRatio;
-    const radiusDelay = radius + 2;
-    const markerSize = radius * 2;
-    const size = radiusDelay * 2 + margin * 2 + 100 * pixelRatio;
-    const origin = size / 2;
-    const canvas = createCanvas(size, size);
-    if (canvas) {
-      const ctx = canvas.getContext("2d");
-      if (isDisplayStrokeAndDelay && delay !== null) {
-        const delayBg = getDelayBgCanvas(origin, radiusDelay, getDelayColor(delay, cancelled));
-        ctx.drawImage(delayBg, 0, 0);
-      }
-      if (isDisplayStrokeAndDelay && (hover || delay >= delayDisplay || cancelled)) {
-        const fontSize = Math.max(cancelled ? 19 : 14, Math.min(cancelled ? 19 : 17, radius * 1.2)) * pixelRatio;
-        const text = getDelayText(delay, cancelled);
-        if (text) {
-          const textWidth = text.length * fontSize;
-          const delayText = getDelayTextCanvas(textWidth, text, fontSize, `bold ${fontSize}px arial, sans-serif`, getDelayColor(delay, cancelled, true), delayOutlineColor, pixelRatio);
-          ctx.drawImage(delayText, origin + radiusDelay + margin, origin - fontSize);
+    if (textColor[0] !== '#') {
+        textColor = "#".concat(textColor);
+    }
+    var z = Math.min(Math.floor(zoom || 1), 16);
+    var hover = hoverVehicleId && hoverVehicleId === id;
+    var selected = selectedVehicleId && selectedVehicleId === id;
+    // Calcul the radius of the circle
+    var radius = getRadius(type, z) * pixelRatio;
+    var isDisplayStrokeAndDelay = radius >= 7 * pixelRatio;
+    if (hover || selected) {
+        radius = isDisplayStrokeAndDelay
+            ? radius + 5 * pixelRatio
+            : 14 * pixelRatio;
+    }
+    var mustDrawText = radius > 10 * pixelRatio;
+    // Optimize the cache key, very important in high zoom level
+    var key = "".concat(radius).concat(hover).concat(selected).concat(cancelled).concat(delay);
+    if (useDelayStyle) {
+        key += "".concat(operatorProvidesRealtime);
+    }
+    else {
+        key += "".concat(type).concat(color);
+    }
+    if (mustDrawText) {
+        key += "".concat(name).concat(textColor);
+    }
+    if (!cache[key]) {
+        if (radius === 0) {
+            cache[key] = null;
+            return null;
+        }
+        var margin = 1 * pixelRatio;
+        var radiusDelay = radius + 2;
+        var markerSize = radius * 2;
+        var size = radiusDelay * 2 + margin * 2 + 100 * pixelRatio; // add space for delay information
+        var origin_1 = size / 2;
+        // Create the canvas
+        var canvas = (0, createCanvas_1.default)(size, size);
+        if (canvas) {
+            var ctx = canvas.getContext('2d');
+            if (isDisplayStrokeAndDelay && delay !== null) {
+                // Draw circle delay background
+                var delayBg = (0, exports.getDelayBgCanvas)(origin_1, radiusDelay, getDelayColor(delay, cancelled));
+                ctx.drawImage(delayBg, 0, 0);
+            }
+            // Show delay if feature is hovered or if delay is above 5mins.
+            if (isDisplayStrokeAndDelay &&
+                (hover || delay >= delayDisplay || cancelled)) {
+                // Draw delay text
+                var fontSize = Math.max(cancelled ? 19 : 14, Math.min(cancelled ? 19 : 17, radius * 1.2)) * pixelRatio;
+                var text = getDelayText(delay, cancelled);
+                if (text) {
+                    var textWidth = text.length * fontSize;
+                    var delayText = (0, exports.getDelayTextCanvas)(textWidth, text, fontSize, "bold ".concat(fontSize, "px arial, sans-serif"), getDelayColor(delay, cancelled, true), delayOutlineColor, pixelRatio);
+                    ctx.drawImage(delayText, origin_1 + radiusDelay + margin, origin_1 - fontSize);
+                }
+            }
+            // Draw colored circle with black border
+            var circleFillColor = void 0;
+            if (useDelayStyle) {
+                circleFillColor = getDelayColor(delay, cancelled);
+            }
+            else {
+                circleFillColor = color || getBgColor(type);
+            }
+            var hasStroke = isDisplayStrokeAndDelay || hover || selected;
+            var hasDash = isDisplayStrokeAndDelay &&
+                useDelayStyle &&
+                delay === null &&
+                operatorProvidesRealtime === 'yes';
+            var circle = (0, exports.getCircleCanvas)(origin_1, radius, circleFillColor, hasStroke, hasDash, pixelRatio);
+            ctx.drawImage(circle, 0, 0);
+            // Draw text in the circle
+            if (mustDrawText) {
+                var fontSize = Math.max(radius, 10);
+                var textSize = getTextSize(ctx, markerSize, name, fontSize);
+                var textColor2 = !useDelayStyle
+                    ? textColor || getTextColor(type)
+                    : '#000000';
+                var hasStroke2 = useDelayStyle && delay === null && operatorProvidesRealtime === 'yes';
+                var text = (0, exports.getTextCanvas)(name, origin_1, textSize, textColor2, circleFillColor, hasStroke2, pixelRatio);
+                ctx.drawImage(text, 0, 0);
+            }
+            cache[key] = canvas;
         }
-      }
-      let circleFillColor;
-      if (useDelayStyle) {
-        circleFillColor = getDelayColor(delay, cancelled);
-      } else {
-        circleFillColor = color || getBgColor(type);
-      }
-      const hasStroke = isDisplayStrokeAndDelay || hover || selected;
-      const hasDash = isDisplayStrokeAndDelay && useDelayStyle && delay === null && operatorProvidesRealtime === "yes";
-      const circle = getCircleCanvas(origin, radius, circleFillColor, hasStroke, hasDash, pixelRatio);
-      ctx.drawImage(circle, 0, 0);
-      if (mustDrawText) {
-        const fontSize = Math.max(radius, 10);
-        const textSize = getTextSize(ctx, markerSize, name, fontSize);
-        const textColor2 = !useDelayStyle ? textColor || getTextColor(type) : "#000000";
-        const hasStroke2 = useDelayStyle && delay === null && operatorProvidesRealtime === "yes";
-        const text = getTextCanvas(name, origin, textSize, textColor2, circleFillColor, hasStroke2, pixelRatio);
-        ctx.drawImage(text, 0, 0);
-      }
-      cache[key] = canvas;
     }
-  }
-  return cache[key];
+    return cache[key];
 };
-export default realtimeDefaultStyle;
+exports.default = realtimeDefaultStyle;

package/common/styles/realtimeDelayStyle.d.ts

@@ -0,0 +1,11 @@
+export default realtimeDelayStyle;
+/**
+ * A tracker style that display the delay as backgroundColor.
+ *
+ * @param {*} trajectory The trajectory to render.
+ * @param {*} viewState The view state of the map.
+ * @param {*} options Some options to change the rendering
+ * @return a canvas
+ */
+declare function realtimeDelayStyle(trajectory: any, viewState: any, options: any): any;
+//# sourceMappingURL=realtimeDelayStyle.d.ts.map

package/common/styles/realtimeDelayStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeDelayStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeDelayStyle.js"],"names":[],"mappings":";AAEA;;;;;;;GAOG;AACH,wFAKC"}

package/common/styles/realtimeDelayStyle.js

@@ -1,8 +1,26 @@
-import realtimeDefaultStyle from "./realtimeDefaultStyle";
-const realtimeDelayStyle = (trajectory, viewState, options) => {
-  return realtimeDefaultStyle(trajectory, viewState, {
-    ...options,
-    useDelayStyle: true
-  });
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
 };
-export default realtimeDelayStyle;
+Object.defineProperty(exports, "__esModule", { value: true });
+var realtimeDefaultStyle_1 = require("./realtimeDefaultStyle");
+/**
+ * A tracker style that display the delay as backgroundColor.
+ *
+ * @param {*} trajectory The trajectory to render.
+ * @param {*} viewState The view state of the map.
+ * @param {*} options Some options to change the rendering
+ * @return a canvas
+ */
+var realtimeDelayStyle = function (trajectory, viewState, options) {
+    return (0, realtimeDefaultStyle_1.default)(trajectory, viewState, __assign(__assign({}, options), { useDelayStyle: true }));
+};
+exports.default = realtimeDelayStyle;

package/common/styles/realtimeSimpleStyle.d.ts

@@ -0,0 +1,3 @@
+export default realtimeSimpleStyle;
+declare function realtimeSimpleStyle(): any;
+//# sourceMappingURL=realtimeSimpleStyle.d.ts.map

package/common/styles/realtimeSimpleStyle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"realtimeSimpleStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeSimpleStyle.js"],"names":[],"mappings":";AAKA,4CAeC"}

package/common/styles/realtimeSimpleStyle.js

@@ -1,18 +1,24 @@
-let canvas;
-const realtimeSimpleStyle = () => {
-  if (!canvas) {
-    document.createElement("canvas");
-    canvas.width = 15;
-    canvas.height = 15;
-    const ctx = canvas.getContext("2d");
-    ctx.arc(8, 8, 5, 0, 2 * Math.PI, false);
-    ctx.fillStyle = "#8ED6FF";
-    ctx.fill();
-    ctx.lineWidth = 3;
-    ctx.strokeStyle = "black";
-    ctx.stroke();
-    ctx.lineWidth = 3;
-  }
-  return canvas;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * A very simple tracker style.
+ * Display blue point for each train.
+ */
+var canvas;
+var realtimeSimpleStyle = function () {
+    if (!canvas) {
+        document.createElement('canvas');
+        canvas.width = 15;
+        canvas.height = 15;
+        var ctx = canvas.getContext('2d');
+        ctx.arc(8, 8, 5, 0, 2 * Math.PI, false);
+        ctx.fillStyle = '#8ED6FF';
+        ctx.fill();
+        ctx.lineWidth = 3;
+        ctx.strokeStyle = 'black';
+        ctx.stroke();
+        ctx.lineWidth = 3;
+    }
+    return canvas;
 };
-export default realtimeSimpleStyle;
+exports.default = realtimeSimpleStyle;

package/common/typedefs.d.ts

@@ -0,0 +1,50 @@
+type FilterFunction = Function;
+type ViewState = {
+    /**
+     * A time in ms.
+     */
+    time: number;
+    /**
+     * A center in mercator coordinate.
+     */
+    center: any;
+    /**
+     * An Extent in mercator coordinates.
+     */
+    extent: any;
+    /**
+     * A size ([width, height]).
+     */
+    size: any;
+    /**
+     * A rotation in radians.
+     */
+    rotation: number;
+    /**
+     * A resolution.
+     */
+    resolution: number;
+    /**
+     * A zoom level.
+     */
+    zoom: number;
+    /**
+     * A pixel ratio.
+     */
+    pixelRatio: number;
+};
+type FeatureInfo = {
+    /**
+     * A layer.
+     */
+    layer: Layer;
+    /**
+     * /Feature~Feature[]} features  An array of features.
+     */
+    "": ol;
+    /**
+     * The coordinate where to find the featue.
+     */
+    coordinate: any;
+};
+//# sourceMappingURL=typedefs.d.ts.map

package/common/typedefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typedefs.d.ts","sourceRoot":"","sources":["../../src/common/typedefs.js"],"names":[],"mappings":";;;;;UAOc,MAAM;;;;;;;;;;;;;;;;cAIN,MAAM;;;;gBACN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM"}

package/common/typedefs.js

@@ -0,0 +1,21 @@
+/**
+ * @typedef {function} FilterFunction
+ * @param {Object} vehicle Vehicle to filter.
+ */
+/**
+ * @typedef {Object} ViewState
+ * @property {number} time A time in ms.
+ * @property {number[2]} center A center in mercator coordinate.
+ * @property {number[4]} extent An Extent in mercator coordinates.
+ * @property {number[2]} size A size ([width, height]).
+ * @property {number} rotation A rotation in radians.
+ * @property {number} resolution A resolution.
+ * @property {number} zoom A zoom level.
+ * @property {number} pixelRatio A pixel ratio.
+ */
+/**
+ * @typedef {Object} FeatureInfo
+ * @property {Layer} layer A layer.
+ * @property {ol/Feature~Feature[]} features  An array of features.
+ * @property {number[2]} coordinate The coordinate where to find the featue.
+ */

package/common/utils/cleanStopTime.d.ts

@@ -0,0 +1,7 @@
+export default cleanStopTime;
+/**
+ * Remove the delay from arrivalTime and departureTime
+ * @private
+ */
+declare function cleanStopTime(content: any): any;
+//# sourceMappingURL=cleanStopTime.d.ts.map

package/common/utils/cleanStopTime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanStopTime.d.ts","sourceRoot":"","sources":["../../../src/common/utils/cleanStopTime.js"],"names":[],"mappings":";AAAA;;;GAGG;AACH,kDAsBC"}