mobility-toolbox-js 2.0.0-beta.36 → 2.0.0-beta.39

package/common/mixins/UserInteractionsLayerMixin.test.js

@@ -0,0 +1,214 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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(undefined);
+            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(undefined);
+            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', (done) => __awaiter(void 0, void 0, void 0, function* () {
+            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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"realtimeDefaultStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeDefaultStyle.js"],"names":[],"mappings":"AAUO,4EAeN;AAUM,2JA2BN;AAUM,0HAoCN;AAUM,6IAuCN;;AAKD;;;;;;;GAOG;AACH,0FAgMC"}
+{"version":3,"file":"realtimeDefaultStyle.d.ts","sourceRoot":"","sources":["../../../src/common/styles/realtimeDefaultStyle.js"],"names":[],"mappings":"AAUO,4EAeN;AAUM,2JA2BN;AAUM,0HAoCN;AAUM,6IAuCN;;AAKD;;;;;;;GAOG;AACH,0FA8LC"}

package/common/styles/realtimeDefaultStyle.js

@@ -130,12 +130,10 @@ const cache = {};
 const realtimeDefaultStyle = (trajectory, viewState, options) => {
     const { hoverVehicleId, selectedVehicleId, useDelayStyle, delayOutlineColor = '#000', delayDisplay = 300000, getRadius, getBgColor, getDelayColor, getDelayText, getTextColor, getTextSize, } = options;
     const { zoom, pixelRatio } = viewState;
-    let { type, cancelled } = trajectory.properties;
+    let { type } = trajectory.properties;
     const { train_id: id, line, delay, state, operator_provides_realtime_journey: operatorProvidesRealtime, } = trajectory.properties;
     let { name, text_color: textColor, color } = line || {};
-    // 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';
+    const cancelled = state === 'JOURNEY_CANCELLED';
     if (!type) {
         type = 'Rail';
     }

package/common/styles/realtimeSimpleStyle.js

@@ -5,7 +5,7 @@
 let canvas;
 const realtimeSimpleStyle = () => {
     if (!canvas) {
-        document.createElement('canvas');
+        canvas = document.createElement('canvas');
         canvas.width = 15;
         canvas.height = 15;
         const ctx = canvas.getContext('2d');

package/common/utils/createTrackerFilters.test.d.ts

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

package/common/utils/createTrackerFilters.test.d.ts.map

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

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/common/utils/getMapboxMapCopyrights.test.d.ts

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

package/common/utils/getMapboxMapCopyrights.test.d.ts.map

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

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">© 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">© OpenMapTiles</a>',
+            '<a href="https://www.openstreetmap.org/about/" target="_blank">© OpenStreetMap contributors</a>',
+            '<a href="https://www.imagico.de/" target="_blank">© imagico</a>',
+        ]);
+    });
+});

package/common/utils/removeDuplicate.test.d.ts

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

package/common/utils/removeDuplicate.test.d.ts.map

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

package/common/utils/removeDuplicate.test.js

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

package/common/utils/timeUtils.test.d.ts

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

package/common/utils/timeUtils.test.d.ts.map

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

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/common/utils/trackerConfig.test.d.ts

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

package/common/utils/trackerConfig.test.d.ts.map

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

package/common/utils/trackerConfig.test.js

@@ -0,0 +1,23 @@
+import { getTypeIndex } from './trackerConfig';
+describe('trackerConfig', () => {
+    describe('#getTypeIndex()', () => {
+        test("retrurn the type is it's not a string", () => {
+            const obj = { foo: 'foo' };
+            expect(getTypeIndex(obj)).toBe(obj);
+            expect(getTypeIndex(0)).toBe(0);
+            expect(getTypeIndex(null)).toBe(null);
+            expect(getTypeIndex(undefined)).toBe(undefined);
+        });
+        test('find good index for new tracker values', () => {
+            expect(getTypeIndex('tram')).toBe(0);
+            expect(getTypeIndex('subway')).toBe(1);
+            expect(getTypeIndex('bus')).toBe(3);
+            expect(getTypeIndex('ferry')).toBe(4);
+            expect(getTypeIndex('cablecar')).toBe(5);
+            expect(getTypeIndex('gondola')).toBe(6);
+            expect(getTypeIndex('funicular')).toBe(7);
+            expect(getTypeIndex('coach')).toBe(8);
+            expect(getTypeIndex('rail')).toBe(9);
+        });
+    });
+});

package/mapbox/layers/Layer.test.d.ts

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

package/mapbox/layers/Layer.test.d.ts.map

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