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

package/common/mixins/UserInteractionsLayerMixin.test.js

@@ -1,199 +0,0 @@
-import VectorLayer from "ol/layer/Vector";
-import VectorSource from "ol/source/Vector";
-import BaseLayer from "../layers/Layer";
-import mixin from "./UserInteractionsLayerMixin";
-const olLayer = new VectorLayer({ source: new VectorSource() });
-const Layer = mixin(BaseLayer);
-describe("Layer", () => {
-  test("should initialize.", () => {
-    const layer = new Layer();
-    expect(layer).toBeInstanceOf(Layer);
-  });
-  test("should define default properties.", () => {
-    const layer = new Layer();
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.userInteractions).toEqual(true);
-    expect(layer.userClickInteractions).toEqual(true);
-    expect(layer.userHoverInteractions).toEqual(true);
-    expect(layer.defaultUserInteractions).toBe(true);
-    expect(layer.userClickCallbacks).toEqual([]);
-    expect(layer.userHoverCallbacks).toEqual([]);
-    expect(layer.userClickEventsKeys).toEqual([]);
-    expect(layer.userHoverEventsKeys).toEqual([]);
-  });
-  test("should set userInteractionsXXX to false.", () => {
-    const options = {
-      userInteractions: false,
-      userClickInteractions: false,
-      userHoverInteractions: false,
-      defaultUserInteractions: false
-    };
-    const layer = new Layer(options);
-    expect(layer).toBeInstanceOf(Layer);
-    expect(layer.userInteractions).toBe(false);
-    expect(layer.userClickInteractions).toBe(false);
-    expect(layer.userHoverInteractions).toBe(false);
-    expect(layer.defaultUserInteractions).toBe(false);
-  });
-  test("should set onClick using constructor", () => {
-    const fn = () => {
-    };
-    const layer = new Layer({
-      onClick: fn,
-      onHover: fn
-    });
-    expect(layer.userClickCallbacks[0]).toBe(fn);
-    expect(layer.userHoverCallbacks[0]).toBe(fn);
-    expect(layer.userClickEventsKeys.length).toBe(0);
-    expect(layer.userHoverEventsKeys.length).toBe(0);
-  });
-  describe("#attachToMap()", () => {
-    test("should not add events if no callbacks", () => {
-      const layer = new Layer({
-        olLayer
-      });
-      expect(layer.map).toBe(void 0);
-      const obj = {};
-      layer.attachToMap(obj);
-      expect(layer.userClickEventsKeys.length).toBe(0);
-      expect(layer.userHoverEventsKeys.length).toBe(0);
-    });
-    test("should add events", () => {
-      const fn = () => {
-      };
-      const layer = new Layer({
-        olLayer,
-        onClick: fn,
-        onHover: fn
-      });
-      expect(layer.map).toBe(void 0);
-      const obj = {};
-      layer.attachToMap(obj);
-      expect(layer.userClickEventsKeys.length).toBe(1);
-      expect(layer.userHoverEventsKeys.length).toBe(1);
-    });
-  });
-  describe("#onClick()", () => {
-    test("adds function to callback array", () => {
-      const layer = new Layer();
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onClick(fn);
-      expect(layer.userClickCallbacks).toEqual([fn]);
-      layer.onClick(fn2);
-      expect(layer.userClickCallbacks).toEqual([fn, fn2]);
-      expect(layer.userClickEventsKeys.length).toBe(0);
-      layer.attachToMap({});
-      expect(layer.userClickEventsKeys.length).toBe(2);
-    });
-  });
-  describe("#onHover()", () => {
-    test("adds function to callback array", () => {
-      const layer = new Layer();
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      layer.onHover(fn);
-      expect(layer.userHoverCallbacks).toEqual([fn]);
-      layer.onHover(fn2);
-      expect(layer.userHoverCallbacks).toEqual([fn, fn2]);
-      expect(layer.userHoverEventsKeys.length).toBe(0);
-      layer.attachToMap({});
-      expect(layer.userHoverEventsKeys.length).toBe(2);
-    });
-  });
-  describe("#onUserClickCallback()", () => {
-    const evt = { type: "signleclick", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls click callback functions", async (done) => {
-      const layer = new Layer();
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onClick(fn);
-      layer.onClick(fn2);
-      layer.attachToMap({});
-      layer.onUserClickCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if an error is thrown in click callback", (done) => {
-        const layer = new Layer();
-        layer.onClick(() => {
-          throw new Error("foo");
-        });
-        const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-        jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-        layer.attachToMap({});
-        layer.onUserClickCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-  });
-  describe("#onUserMoveCallback()", () => {
-    const evt = { type: "pointermove", coordinate: [0, 0] };
-    const getFeatureInfo = (layer, features = []) => ({
-      features,
-      layer,
-      coordinate: evt.coordinate,
-      event: evt
-    });
-    test("calls hover callback functions", (done) => {
-      const layer = new Layer();
-      const goodFeatureInfo = getFeatureInfo(layer, [{ name: "test" }]);
-      const fn = jest.fn();
-      const fn2 = jest.fn();
-      const spy = jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(goodFeatureInfo);
-      layer.onHover(fn);
-      layer.onHover(fn2);
-      layer.attachToMap({});
-      layer.onUserMoveCallback(evt).then((featureInfo) => {
-        expect(spy).toHaveBeenCalledTimes(1);
-        expect(spy).toHaveBeenCalledWith(evt.coordinate);
-        expect(featureInfo).toBe(goodFeatureInfo);
-        expect(fn).toHaveBeenCalledTimes(1);
-        expect(fn.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        expect(fn2).toHaveBeenCalledTimes(1);
-        expect(fn2.mock.calls[0][0]).toBe(goodFeatureInfo.features);
-        expect(fn2.mock.calls[0][1]).toBe(goodFeatureInfo.layer);
-        expect(fn2.mock.calls[0][2]).toBe(goodFeatureInfo.coordinate);
-        done();
-      });
-    });
-    describe("returns empty feature info", () => {
-      test("if an error is thrown in hover callback", (done) => {
-        const layer = new Layer();
-        layer.onHover(() => {
-          throw new Error("foo");
-        });
-        jest.spyOn(layer, "getFeatureInfoAtCoordinate").mockResolvedValue(getFeatureInfo(layer, [{ name: "test" }]));
-        layer.attachToMap({});
-        layer.onUserMoveCallback(evt).then((featureInfo) => {
-          expect(featureInfo).toEqual(getFeatureInfo(layer));
-          done();
-        });
-      });
-    });
-  });
-});

package/common/styles/realtimeDefaultStyle.js

@@ -1,202 +0,0 @@
-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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-  }
-  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;
-    }
-    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);
-        }
-      }
-      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];
-};
-export default realtimeDefaultStyle;

package/common/styles/realtimeDelayStyle.js

@@ -1,8 +0,0 @@
-import realtimeDefaultStyle from "./realtimeDefaultStyle";
-const realtimeDelayStyle = (trajectory, viewState, options) => {
-  return realtimeDefaultStyle(trajectory, viewState, {
-    ...options,
-    useDelayStyle: true
-  });
-};
-export default realtimeDelayStyle;

package/common/styles/realtimeSimpleStyle.js

@@ -1,18 +0,0 @@
-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;
-};
-export default realtimeSimpleStyle;

package/common/utils/cleanStopTime.js

@@ -1,19 +0,0 @@
-const cleanStopTime = (content) => {
-  if (!content) {
-    return;
-  }
-  content.stations.forEach((station) => {
-    station.arrivalTimeWithDelay = station.arrivalTime;
-    if (station.departureTime) {
-      station.departureTimeWithDelay = station.departureTime;
-    }
-    if (station.arrivalDelay) {
-      station.arrivalTime -= station.arrivalDelay;
-      if (station.departureTime) {
-        station.departureTime -= station.arrivalDelay;
-      }
-    }
-  });
-  return content;
-};
-export default cleanStopTime;

package/common/utils/compareDepartures.js

@@ -1,25 +0,0 @@
-const compareDepartures = (a, b, sortByMinArrivalTime = false) => {
-  const topStates = ["HIDDEN", "LEAVING", "BOARDING"];
-  const aTop = a.has_fzo && topStates.indexOf(a.state) > -1;
-  const bTop = b.has_fzo && topStates.indexOf(b.state) > -1;
-  if (aTop || bTop) {
-    if (aTop !== bTop) {
-      return aTop ? -1 : 1;
-    }
-    if (a.state !== b.state) {
-      return topStates.indexOf(a.state) - topStates.indexOf(b.state);
-    }
-  }
-  let aDuration = null;
-  let bDuration = null;
-  const now = Date.now();
-  if (sortByMinArrivalTime) {
-    aDuration = new Date(a.min_arrival_time || a.time).getTime() - now;
-    bDuration = new Date(b.min_arrival_time || b.time).getTime() - now;
-  } else {
-    aDuration = new Date(a.time).getTime() - now;
-    bDuration = new Date(b.time).getTime() - now;
-  }
-  return aDuration - bDuration;
-};
-export default compareDepartures;

package/common/utils/createCanvas.js

@@ -1,17 +0,0 @@
-const createCanvas = (width, height) => {
-  let canvas = null;
-  if (typeof window === "undefined") {
-    return null;
-  }
-  if (document?.createElement) {
-    canvas = document.createElement("canvas");
-    canvas.width = width;
-    canvas.height = height;
-  } else if (OffscreenCanvas) {
-    canvas = new OffscreenCanvas(width, height);
-  } else {
-    console.error("We didn't find a way to create a canvas element, document.createElement('canvas') and new OffscrenCanvas() are not supported");
-  }
-  return canvas;
-};
-export default createCanvas;

package/common/utils/createTrackerFilters.js

@@ -1,56 +0,0 @@
-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

@@ -1,79 +0,0 @@
-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/common/utils/getLayersAsFlatArray.js

@@ -1,14 +0,0 @@
-const getLayersAsFlatArray = (layersOrLayer) => {
-  let layers = layersOrLayer;
-  if (!Array.isArray(layers)) {
-    layers = [layersOrLayer];
-  }
-  let flatLayers = [];
-  layers.forEach((layer) => {
-    flatLayers.push(layer);
-    const { children } = layer;
-    flatLayers = flatLayers.concat(getLayersAsFlatArray(children || []));
-  });
-  return flatLayers;
-};
-export default getLayersAsFlatArray;

package/common/utils/getMapboxMapCopyrights.js

@@ -1,19 +0,0 @@
-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;
-      if (attribution) {
-        copyrights = copyrights.concat(attribution.replace(/&copy;/g, "\xA9").split(/(<a.*?<\/a>)/));
-      }
-    }
-  });
-  return removeDuplicate(copyrights);
-};
-export default getMapboxMapCopyrights;