@wemap/routers 6.2.3 → 7.0.0

package/src/model/LevelChange.spec.js

@@ -0,0 +1,78 @@
+import chai from 'chai';
+
+import LevelChange from './LevelChange.js';
+import checkLevelChangeType from './LevelChange.type.spec.js';
+
+const { expect } = chai;
+
+const levelChange1 = new LevelChange();
+levelChange1.direction = 'up';
+levelChange1.difference = 1;
+levelChange1.type = 'stairs';
+
+const levelChange2 = new LevelChange();
+levelChange2.direction = 'down';
+levelChange2.difference = -1;
+levelChange2.type = 'elevator';
+
+const levelChange3 = new LevelChange();
+levelChange3.direction = 'up';
+levelChange3.difference = 3;
+levelChange3.type = 'conveyor';
+
+const levelChange4 = new LevelChange();
+levelChange4.direction = 'up';
+levelChange4.difference = 1;
+
+const levelChange5 = new LevelChange();
+levelChange5.direction = 'up';
+levelChange5.difference = 1;
+
+describe('LevelChange', () => {
+
+    it('checkTypes', () => {
+        checkLevelChangeType(levelChange1);
+        checkLevelChangeType(levelChange2);
+        checkLevelChangeType(levelChange3);
+        checkLevelChangeType(levelChange4);
+        checkLevelChangeType(levelChange5);
+    });
+
+    it('equals', () => {
+        expect(levelChange1.equalsTo(levelChange1)).is.true;
+        expect(levelChange2.equalsTo(levelChange2)).is.true;
+        expect(levelChange3.equalsTo(levelChange3)).is.true;
+        expect(levelChange4.equalsTo(levelChange4)).is.true;
+        expect(levelChange4.equalsTo(levelChange5)).is.true;
+        expect(levelChange1.equalsTo(levelChange2)).is.false;
+        expect(levelChange1.equalsTo(levelChange3)).is.false;
+        expect(levelChange1.equalsTo(levelChange4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const levelChange1Json = levelChange1.toJson();
+        expect(levelChange1Json).be.an('object');
+        const levelChange1Bis = LevelChange.fromJson(levelChange1Json);
+        expect(levelChange1.equalsTo(levelChange1Bis)).is.true;
+
+        const levelChange2Json = levelChange2.toJson();
+        expect(levelChange2Json).be.an('object');
+        const levelChange2Bis = LevelChange.fromJson(levelChange2Json);
+        expect(levelChange2.equalsTo(levelChange2Bis)).is.true;
+
+        const levelChange3Json = levelChange3.toJson();
+        expect(levelChange3Json).be.an('object');
+        const levelChange3Bis = LevelChange.fromJson(levelChange3Json);
+        expect(levelChange3.equalsTo(levelChange3Bis)).is.true;
+
+        const levelChange4Json = levelChange4.toJson();
+        expect(levelChange4Json).be.an('object');
+        const levelChange4Bis = LevelChange.fromJson(levelChange4Json);
+        expect(levelChange4.equalsTo(levelChange4Bis)).is.true;
+
+    });
+
+});
+
+export { levelChange1, levelChange2, levelChange3, levelChange4 };

package/src/model/LevelChange.type.spec.js

@@ -0,0 +1,26 @@
+import chai from 'chai';
+
+import LevelChange from './LevelChange.js';
+
+const { expect } = chai;
+
+const isNullOrString = val => val === null || typeof val === 'string';
+
+/**
+ * @param {LevelChange} levelChange
+ */
+export default function checkLevelChangeType(levelChange) {
+
+    expect(levelChange).instanceOf(LevelChange);
+
+    const { direction, difference, type } = levelChange;
+
+    expect(direction).satisfies(str => ['up', 'down'].includes(str));
+    expect(difference).be.a('number');
+    expect(difference !== 0).is.true;
+    expect(difference < 0 ? direction === 'down' : direction === 'up').is.true;
+    expect(type).satisfies(isNullOrString);
+    if (type) {
+        expect(type).satisfies(str => ['elevator', 'conveyor', 'stairs'].includes(str));
+    }
+}

package/src/model/RouterResponse.js

@@ -1,9 +1,10 @@
 import { Coordinates } from '@wemap/geo';
 
 import Itinerary from './Itinerary.js';
+
 class RouterResponse {
 
-    /** @type {!string} */
+    /** @type {!string|Array<string>} */
     routerName;
 
     /** @type {!Coordinates} */
@@ -14,6 +15,74 @@ class RouterResponse {
 
     /** @type {!(Itinerary[])} */
     itineraries = [];
+
+    /** @type {?object} */
+    error = null;
+
+    /**
+     * @param {RouterResponse} obj1
+     * @param {RouterResponse} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        const intermediate = obj1.routerName === obj2.routerName
+            && obj1.from.equalsTo(obj2.from)
+            && obj1.to.equalsTo(obj2.to)
+            && obj1.itineraries.length === obj2.itineraries.length;
+
+        if (!intermediate) {
+            return false;
+        }
+
+        for (let i = 0; i < obj1.itineraries.length; i++) {
+            if (!obj1.itineraries[i].equalsTo(obj2.itineraries[i])) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    /**
+     * @param {RouterResponse} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return RouterResponse.equalsTo(this, obj);
+    }
+
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        const json = {
+            routerName: this.routerName,
+            from: this.from.toCompressedJson(),
+            to: this.to.toCompressedJson(),
+            itineraries: this.itineraries.map(itinerary => itinerary.toJson())
+        };
+        if (this.error) {
+            json.error = this.error;
+        }
+        return json;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {RouterResponse}
+     */
+    static fromJson(json) {
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = json.routerName;
+        routerResponse.from = Coordinates.fromCompressedJson(json.from);
+        routerResponse.to = Coordinates.fromCompressedJson(json.to);
+        routerResponse.itineraries = json.itineraries.map(Itinerary.fromJson);
+        if (json.error) {
+            routerResponse.error = json.error;
+        }
+        return routerResponse;
+    }
 }
 
 export default RouterResponse;

package/src/model/RouterResponse.spec.js

@@ -0,0 +1,85 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from './RouterResponse.js';
+import checkRouterResponseType from './RouterResponse.type.spec.js';
+import { itinerary1, itinerary2, itinerary3, itinerary4 } from './Itinerary.spec.js';
+
+const { expect } = chai;
+
+const routerResponse1 = new RouterResponse();
+routerResponse1.routerName = 'foo1';
+routerResponse1.from = new Coordinates(0, 0);
+routerResponse1.to = new Coordinates(1, 0);
+routerResponse1.itineraries = [itinerary1];
+
+const routerResponse2 = new RouterResponse();
+routerResponse2.routerName = 'foo2';
+routerResponse2.from = new Coordinates(0, 0);
+routerResponse2.to = new Coordinates(1, 0);
+routerResponse2.itineraries = [itinerary1, itinerary2];
+
+const routerResponse3 = new RouterResponse();
+routerResponse3.routerName = 'foo3';
+routerResponse3.from = new Coordinates(0, 0);
+routerResponse3.to = new Coordinates(2, 0);
+routerResponse3.itineraries = [itinerary1, itinerary2, itinerary3, itinerary4];
+
+const routerResponse4 = new RouterResponse();
+routerResponse4.routerName = 'foo4';
+routerResponse4.from = new Coordinates(1, 0);
+routerResponse4.to = new Coordinates(4, 0);
+routerResponse4.itineraries = [itinerary1];
+
+const routerResponse5 = new RouterResponse();
+Object.assign(routerResponse5, routerResponse4);
+
+describe('RouterResponse', () => {
+
+    it('checkTypes', () => {
+        checkRouterResponseType(routerResponse1);
+        checkRouterResponseType(routerResponse2);
+        checkRouterResponseType(routerResponse3);
+        checkRouterResponseType(routerResponse4);
+    });
+
+    it('equals', () => {
+        expect(routerResponse1.equalsTo(routerResponse1)).is.true;
+        expect(routerResponse2.equalsTo(routerResponse2)).is.true;
+        expect(routerResponse3.equalsTo(routerResponse3)).is.true;
+        expect(routerResponse4.equalsTo(routerResponse4)).is.true;
+        expect(routerResponse4.equalsTo(routerResponse5)).is.true;
+        expect(routerResponse1.equalsTo(routerResponse2)).is.false;
+        expect(routerResponse1.equalsTo(routerResponse3)).is.false;
+        expect(routerResponse1.equalsTo(routerResponse4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const routerResponse1Json = routerResponse1.toJson();
+        expect(routerResponse1Json).be.an('object');
+        const routerResponse1Bis = RouterResponse.fromJson(routerResponse1Json);
+        expect(routerResponse1.equalsTo(routerResponse1Bis)).is.true;
+
+        const routerResponse2Json = routerResponse2.toJson();
+        expect(routerResponse2Json).be.an('object');
+        const routerResponse2Bis = RouterResponse.fromJson(routerResponse2Json);
+        expect(routerResponse2.equalsTo(routerResponse2Bis)).is.true;
+
+        const routerResponse3Json = routerResponse3.toJson();
+        expect(routerResponse3Json).be.an('object');
+        const routerResponse3Bis = RouterResponse.fromJson(routerResponse3Json);
+        expect(routerResponse3.equalsTo(routerResponse3Bis)).is.true;
+
+        const routerResponse4Json = routerResponse4.toJson();
+        expect(routerResponse4Json).be.an('object');
+        const routerResponse4Bis = RouterResponse.fromJson(routerResponse4Json);
+        expect(routerResponse4.equalsTo(routerResponse4Bis)).is.true;
+
+    });
+
+});
+
+export { routerResponse1, routerResponse2, routerResponse3, routerResponse4 };

package/src/model/RouterResponse.type.spec.js

@@ -4,21 +4,24 @@ import { Coordinates } from '@wemap/geo';
 
 import RouterResponse from './RouterResponse.js';
 
-import { verifyItineraryData } from './Itinerary.type.spec.js';
+import checkItineraryType from './Itinerary.type.spec.js';
 
 const { expect } = chai;
 
 /**
  * @param {RouterResponse} routerResponse
  */
-export function verifyRouterResponseData(routerResponse) {
+export default function checkRouterResponseType(routerResponse) {
 
     expect(routerResponse).instanceOf(RouterResponse);
-    expect(routerResponse.routerName).be.a('string');
+    expect(routerResponse.routerName).satisfy(val => {
+        return typeof val === 'string'
+            || Array.isArray(val) && val.every(val2 => typeof val2 === 'string');
+    });
     expect(routerResponse.from).instanceOf(Coordinates);
     expect(routerResponse.to).instanceOf(Coordinates);
     expect(routerResponse.itineraries).be.an('array');
-    routerResponse.itineraries.forEach(verifyItineraryData);
+    routerResponse.itineraries.forEach(checkItineraryType);
 
 }
 

package/src/model/Step.js

@@ -46,6 +46,45 @@ class Step {
     /** @type {!number} */
     _idCoordsInLeg = null;
 
+    /**
+     * @param {Step} obj1
+     * @param {Step} obj2
+     * @returns {Boolean}
+     */
+    static equalsTo(obj1, obj2) {
+        return obj1.firstStep === obj2.firstStep
+            && obj1.lastStep === obj2.lastStep
+            && obj1.number === obj2.number
+            && obj1.coords.equalsTo(obj2.coords)
+            && obj1.angle === obj2.angle
+            && obj1.previousBearing === obj2.previousBearing
+            && obj1.nextBearing === obj2.nextBearing
+            && obj1.distance === obj2.distance
+            && obj1.duration === obj2.duration
+            && obj1.name === obj2.name
+            && (
+                obj1.levelChange === obj2.levelChange
+                || obj1.levelChange !== null && obj1.levelChange.equalsTo(obj2.levelChange)
+            )
+            && (
+                obj1.extras === obj2.extras
+                || (
+                    obj1.extras !== null
+                    && obj1.extras.subwayEntrance === obj2.extras.subwayEntrance
+                    && obj1.extras.subwayEntranceRef === obj2.extras.subwayEntranceRef
+                )
+            )
+            && obj1._idCoordsInLeg === obj2._idCoordsInLeg;
+    }
+
+    /**
+     * @param {Step} obj
+     * @returns {Boolean}
+     */
+    equalsTo(obj) {
+        return Step.equalsTo(this, obj);
+    }
+
     /**
      * @returns {object}
      */
@@ -93,22 +132,22 @@ class Step {
         step.nextBearing = json.nextBearing;
         step.distance = json.distance;
         step._idCoordsInLeg = json._idCoordsInLeg;
-        if (json.firstStep) {
+        if (typeof json.firstStep === 'boolean') {
             step.firstStep = json.firstStep;
         }
-        if (json.lastStep) {
+        if (typeof json.lastStep === 'boolean') {
             step.lastStep = json.lastStep;
         }
-        if (json.duration) {
+        if (typeof json.duration === 'number') {
             step.duration = json.duration;
         }
-        if (json.name) {
+        if (typeof json.name === 'string') {
             step.name = json.name;
         }
-        if (json.levelChange) {
+        if (typeof json.levelChange === 'object') {
             step.levelChange = LevelChange.fromJson(json.levelChange);
         }
-        if (json.extras) {
+        if (typeof json.extras === 'object') {
             step.extras = json.extras;
         }
         return step;

package/src/model/Step.spec.js

@@ -0,0 +1,100 @@
+/* eslint-disable max-statements */
+import { Coordinates } from '@wemap/geo';
+import chai from 'chai';
+
+import Step from './Step.js';
+import checkStepType from './Step.type.spec.js';
+import { levelChange1 } from './LevelChange.spec.js';
+
+const { expect } = chai;
+
+const step1 = new Step();
+step1.firstStep = true;
+step1.lastStep = false;
+step1.number = 1;
+step1.coords = new Coordinates(0, 0);
+step1.angle = 0;
+step1.previousBearing = 0;
+step1.nextBearing = 0;
+step1.distance = 10;
+step1._idCoordsInLeg = 0;
+
+const step2 = new Step();
+Object.assign(step2, step1);
+step2.firstStep = false;
+step2.number = 2;
+step2.coords = new Coordinates(1, 0);
+step2.distance = step1.coords.distanceTo(step2.coords);
+step2.extras = { subwayEntrance: true, subwayEntranceRef: 'toto' };
+step2._idCoordsInLeg = 1;
+
+const step3 = new Step();
+Object.assign(step3, step2);
+step3.number = 3;
+step3.coords = new Coordinates(2, 0, null);
+step3.distance = step2.coords.distanceTo(step3.coords);
+step3.duration = step3.distance * 2;
+step3.levelChange = levelChange1;
+step3.extras = { subwayEntrance: false };
+step3._idCoordsInLeg = 2;
+
+const step4 = new Step();
+Object.assign(step4, step3);
+step4.lastStep = true;
+step4.number = 4;
+step4.coords = new Coordinates(3, 0);
+step4.distance = step3.coords.distanceTo(step4.coords);
+step4.name = 'end';
+step4.extras = {};
+step4._idCoordsInLeg = 3;
+
+const step5 = new Step();
+Object.assign(step5, step4);
+
+describe('Step', () => {
+
+    it('checkTypes', () => {
+        checkStepType(step1);
+        checkStepType(step2);
+        checkStepType(step3);
+        checkStepType(step4);
+    });
+
+    it('equals', () => {
+        expect(step1.equalsTo(step1)).is.true;
+        expect(step2.equalsTo(step2)).is.true;
+        expect(step3.equalsTo(step3)).is.true;
+        expect(step4.equalsTo(step4)).is.true;
+        expect(step4.equalsTo(step5)).is.true;
+        expect(step1.equalsTo(step2)).is.false;
+        expect(step1.equalsTo(step3)).is.false;
+        expect(step1.equalsTo(step4)).is.false;
+    });
+
+    it('from / to JSON', () => {
+
+        const step1Json = step1.toJson();
+        expect(step1Json).be.an('object');
+        const step1Bis = Step.fromJson(step1Json);
+        expect(step1.equalsTo(step1Bis)).is.true;
+
+        const step2Json = step2.toJson();
+        expect(step2Json).be.an('object');
+        const step2Bis = Step.fromJson(step2Json);
+        expect(step2.equalsTo(step2Bis)).is.true;
+
+        const step3Json = step3.toJson();
+        expect(step3Json).be.an('object');
+        const step3Bis = Step.fromJson(step3Json);
+        expect(step3.equalsTo(step3Bis)).is.true;
+
+        const step4Json = step4.toJson();
+        expect(step4Json).be.an('object');
+        const step4Bis = Step.fromJson(step4Json);
+        expect(step4.equalsTo(step4Bis)).is.true;
+
+    });
+
+});
+
+export { step1, step2, step3, step4 };

package/src/model/Step.type.spec.js

@@ -0,0 +1,52 @@
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import LevelChange from './LevelChange.js';
+import Step from './Step.js';
+import checkLevelChangeType from './LevelChange.type.spec.js';
+
+const { expect } = chai;
+
+
+const isNullOrNumber = val => val === null || typeof val === 'number';
+const isNullOrString = val => val === null || typeof val === 'string';
+const isNullOrObject = val => val === null || typeof val === 'object';
+const isNullOrLevelChange = val => val === null || val instanceof LevelChange;
+
+const isUndefinedOrBoolean = val => typeof val === 'undefined' || typeof val === 'boolean';
+const isUndefinedOrString = val => typeof val === 'undefined' || typeof val === 'string';
+
+const stepExtraProperties = ['subwayEntrance', 'subwayEntranceRef'];
+
+/**
+ * @param {Step} step
+ */
+export default function checkStepType(step) {
+
+    expect(step).instanceOf(Step);
+    expect(step.firstStep).be.a('boolean');
+    expect(step.lastStep).be.a('boolean');
+    expect(step.number).be.a('number');
+    expect(step.coords).instanceOf(Coordinates);
+    expect(step.angle).be.a('number');
+    expect(step.previousBearing).be.a('number');
+    expect(step.nextBearing).be.a('number');
+    expect(step.distance).be.a('number');
+    expect(step.duration).satisfies(isNullOrNumber);
+    expect(step.name).satisfies(isNullOrString);
+    expect(step.levelChange).satisfies(isNullOrLevelChange);
+    if (step.levelChange) {
+        checkLevelChangeType(step.levelChange);
+    }
+    expect(step._idCoordsInLeg).be.a('number');
+
+    expect(step.extras).satisfies(isNullOrObject);
+    if (step.extras !== null) {
+        for (const key of Object.keys(step.extras)) {
+            expect(stepExtraProperties).includes(key);
+        }
+        expect(step.extras.subwayEntrance).satisfies(isUndefinedOrBoolean);
+        expect(step.extras.subwayEntranceRef).satisfies(isUndefinedOrString);
+    }
+}

package/src/remote/RemoteRouter.js

@@ -0,0 +1,31 @@
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from '../model/RouterResponse.js';
+import RemoteRouterOptions from './RemoteRouterOptions.js';
+
+class RemoteRouter {
+
+    /**
+     * Get the router name
+     * @type {string} the router name
+     */
+    get rname() {
+        return 'Unknown';
+    }
+
+    /**
+     * @abstract
+     * @param {string} endpointUrl
+     * @param {string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async getItineraries(endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        throw new Error('RemoteRouter "' + this.rname + '" does not @override getItineraries()');
+    }
+
+}
+
+export default RemoteRouter;

package/src/remote/RemoteRouterManager.js

@@ -0,0 +1,84 @@
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from '../model/RouterResponse.js';
+import RemoteRouter from './RemoteRouter.js';
+import CitywayRemoteRouter from './cityway/CitywayRemoteRouter.js';
+import DeutscheBahnRemoteRouter from './deutsche-bahn/DeutscheBahnRemoteRouter.js';
+import IdfmRemoteRouter from './idfm/IdfmRemoteRouter.js';
+import OsrmRemoteRouter from './osrm/OsrmRemoteRouter.js';
+import OtpRemoteRouter from './otp/OtpRemoteRouter.js';
+import RemoteRouterOptions from './RemoteRouterOptions.js';
+import RemoteRouterServerUnreachable from './RemoteRouterServerUnreachable.js';
+import RoutingModeCorrespondanceNotFound from './RoutingModeCorrespondanceNotFound.js';
+import IdfmRemoteRouterTokenError from './idfm/IdfmRemoteRouterTokenError.js';
+
+/**
+ * Singleton
+ */
+class RemoteRouterManager {
+
+    /** @type {RemoteRouter[]} */
+    remoteRouters = [
+        CitywayRemoteRouter,
+        DeutscheBahnRemoteRouter,
+        IdfmRemoteRouter,
+        OsrmRemoteRouter,
+        OtpRemoteRouter
+    ];
+
+    /**
+     * @param {string} name
+     * @returns {RemoteRouter}
+     */
+    getRouterByName(name) {
+        return this.remoteRouters.find(remoteRouter => remoteRouter.rname === name);
+    }
+
+    /**
+     * @param {!string} endpointUrl
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItineraries(name, endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        const router = this.getRouterByName(name);
+        if (!router) {
+            throw new Error(`Unknown "${this.rname}" remote router`);
+        }
+        return router.getItineraries(endpointUrl, mode, waypoints, options);
+    }
+
+
+    /**
+     * @param {!{name: string, endpointUrl: string}[]} remoteRouters
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {!Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItinerariesWithFallback(remoteRouters, mode, waypoints, options = new RemoteRouterOptions()) {
+        let routerResponse;
+        for (const { name, endpointUrl } of remoteRouters) {
+            routerResponse = await this.getItineraries(name, endpointUrl, mode, waypoints, options);
+            if (routerResponse.itineraries.length) {
+                return routerResponse;
+            }
+        }
+        if (!routerResponse) {
+            routerResponse = new RouterResponse();
+            routerResponse.from = waypoints[0];
+            routerResponse.to = waypoints[waypoints.length];
+        }
+        return routerResponse;
+    }
+
+}
+
+export default new RemoteRouterManager();

package/src/remote/RemoteRouterOptions.js

@@ -0,0 +1,25 @@
+class RemoteRouterOptions {
+
+    /** @type {boolean} */
+    useStairs = true;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return { useStairs: this.useStairs };
+    }
+
+    /**
+     * @param {object}
+     * @returns {RemoteRouterOptions}
+     */
+    static fromJson(json) {
+        const obj = new RemoteRouterOptions();
+        obj.useStairs = json.useStairs;
+        return obj;
+    }
+
+}
+
+export default RemoteRouterOptions;

package/src/remote/RemoteRouterServerUnreachable.js

@@ -0,0 +1,10 @@
+export default class RemoteRouterServerUnreachable extends Error {
+
+    /**
+     * @param {!string} name
+     * @param {!string} endpointUrl
+     */
+    constructor(name, endpointUrl) {
+        super(`Remote router server ${name} is unreachable. URL: ${endpointUrl}`);
+    }
+}