incyclist-services 1.8.4 → 1.8.6

package/lib/cjs/ride/base/base.js

@@ -108,6 +108,7 @@ let RideModeService = (() => {
         }
         onStarted() { }
         onStopped() { }
+        onStartDevicesReady() { }
         getLogProps() {
             return {};
         }

package/lib/cjs/ride/display/service.js

@@ -109,6 +109,7 @@ let RideDisplayService = (() => {
         startDeviceHandlers;
         isResuming;
         stateUpdateHandler = this.onStateUpdate.bind(this);
+        controlDevicesReadyNotified = false;
         constructor() {
             super('RideDisplay');
             this.debug = this.isDebug();
@@ -116,6 +117,7 @@ let RideDisplayService = (() => {
         async init() {
             await this.closePrevRide();
             this.observer = new types_1.Observer();
+            this.controlDevicesReadyNotified = false;
             try {
                 this.displayService = this.getRideModeService(true);
                 this.displayService.init(this);
@@ -163,13 +165,22 @@ let RideDisplayService = (() => {
                 this.logError(err, 'startWithMissingSensors');
             }
         }
+        startWithMapFallback() {
+            try {
+                const props = this.getStartOverlayProps();
+                const rideProps = this.getRideModeService().getLogProps();
+                this.logEvent({ message: 'start ride maps fallback', ...rideProps, state: props });
+                this.getRideModeService()?.startWithMapFallback?.();
+            }
+            catch (err) {
+                this.logError(err, 'startWithMapFallback');
+            }
+        }
         retryStart() {
             try {
                 const props = this.getStartOverlayProps();
-                this.logEvent({ message: 'button clicked', overlay: 'start overlay', button: 'Retry', state: props, eventSource: 'user', });
-                this.logEvent({ message: 'overlay closed', overlay: 'start overlay' });
                 const rideProps = this.getRideModeService().getLogProps();
-                this.logger.logEvent({ message: 'Start ride retry', ...rideProps,
+                this.logger.logEvent({ message: 'Start ride retry', ...rideProps, state: props,
                     bike: this.getBike(),
                     interface: this.getBikeInterface()
                 });
@@ -183,7 +194,8 @@ let RideDisplayService = (() => {
         async cancelStart() {
             try {
                 const props = this.getStartOverlayProps();
-                this.logEvent({ message: 'button clicked', overlay: 'start overlay', button: 'Cancel', reason: 'user cancel', state: props, eventSource: 'user' });
+                const rideProps = this.getRideModeService().getLogProps();
+                this.logEvent({ message: 'start ride cancel', reason: 'user cancel', ...rideProps, state: props });
                 await this.stopRide({ noStateUpdates: true });
             }
             catch (err) {
@@ -528,6 +540,10 @@ let RideDisplayService = (() => {
         checkStartStatus() {
             const devices = this.isStartDeviceReadyToStart();
             const sensors = this.isSensorsReadyToStart();
+            if (devices && !this.controlDevicesReadyNotified) {
+                this.controlDevicesReadyNotified = true;
+                this.getRideModeService().onStartDevicesReady();
+            }
             const ride = this.getRideModeService().isStartRideCompleted();
             const props = this.getStartOverlayProps();
             this.logEvent({ message: 'start overlay update', ...props });

package/lib/cjs/ride/page/service.js

@@ -292,6 +292,14 @@ let RidePageService = (() => {
                 this.logError(err, 'onIgnoreStart');
             }
         }
+        onStartWithMap() {
+            try {
+                this.getRideDisplay().startWithMapFallback();
+            }
+            catch (err) {
+                this.logError(err, 'onStartWithMap');
+            }
+        }
         onCancelStart() {
             try {
                 this.rideObserver?.stop();
@@ -449,7 +457,11 @@ let RidePageService = (() => {
                 route: props.route,
                 displayObserver: props.displayObserver,
                 displayPosition: props.displayPosition,
-                onDisplayEvent: props.onDisplayEvent
+                onDisplayEvent: props.onDisplayEvent,
+                svInitAllowed: props.svInitAllowed,
+                rideViewNotice: props.rideViewNotice,
+                svCoverageNotice: props.svCoverageNotice,
+                svHasCoverage: props.svHasCoverage
             };
             return displayProps;
         }

package/lib/cjs/ride/route/FreeRideDisplayService.js

@@ -101,7 +101,7 @@ let FreeRideDisplayService = (() => {
             }
         }
         isStartRideCompleted() {
-            return this.currentOptions !== undefined;
+            return this.currentOptions !== undefined && super.isStartRideCompleted();
         }
         selectOption(option) {
             try {

package/lib/cjs/ride/route/GpxDisplayService.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GpxDisplayService = void 0;
 const api_1 = require("../../api");
 const apps_1 = require("../../apps");
+const appstate_1 = require("../../appstate");
 const decorators_1 = require("../../base/decorators");
 const types_1 = require("../../base/types");
 const routes_1 = require("../../routes");
@@ -46,6 +47,9 @@ const SV_UPDATE_FREQ = 3000;
 const SV_MIN_READY = 1500;
 const SV_MIN_DELAY = 1000;
 const SV_START_TIMEOUT = 15000;
+const SV_PHASE_DELAY = 400;
+const SV_SLOW_THRESHOLD = 5000;
+const SV_FALLBACK_HOLD = 1500;
 const SAT_START_TIMEOUT = 15000;
 let GpxDisplayService = (() => {
     let _classSuper = RouteDisplayService_1.RouteDisplayService;
@@ -53,15 +57,18 @@ let GpxDisplayService = (() => {
     let _getGoogleMaps_decorators;
     let _getBindings_decorators;
     let _getRideSettingsDisplay_decorators;
+    let _getAppState_decorators;
     return class GpxDisplayService extends _classSuper {
         static {
             const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             _getGoogleMaps_decorators = [decorators_1.Injectable];
             _getBindings_decorators = [decorators_1.Injectable];
             _getRideSettingsDisplay_decorators = [decorators_1.Injectable];
+            _getAppState_decorators = [decorators_1.Injectable];
             __esDecorate(this, null, _getGoogleMaps_decorators, { kind: "method", name: "getGoogleMaps", static: false, private: false, access: { has: obj => "getGoogleMaps" in obj, get: obj => obj.getGoogleMaps }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getBindings_decorators, { kind: "method", name: "getBindings", static: false, private: false, access: { has: obj => "getBindings" in obj, get: obj => obj.getBindings }, metadata: _metadata }, null, _instanceExtraInitializers);
             __esDecorate(this, null, _getRideSettingsDisplay_decorators, { kind: "method", name: "getRideSettingsDisplay", static: false, private: false, access: { has: obj => "getRideSettingsDisplay" in obj, get: obj => obj.getRideSettingsDisplay }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _getAppState_decorators, { kind: "method", name: "getAppState", static: false, private: false, access: { has: obj => "getAppState" in obj, get: obj => obj.getAppState }, metadata: _metadata }, null, _instanceExtraInitializers);
             if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
         }
         mapLoaded = (__runInitializers(this, _instanceExtraInitializers), false);
@@ -75,23 +82,39 @@ let GpxDisplayService = (() => {
         tsLastPovChanged;
         povTimeout;
         updateDurations = [];
-        svStartTimedOut = false;
-        svStartTimeout;
         satStartTimedOut = false;
         satStartTimeout;
+        tsInit;
+        svFlowActive = false;
+        svViewState = 'waiting';
+        svReleased = false;
+        tsSvReleased;
+        svInitTrigger;
+        svPhaseWasVisible = false;
+        svFallbackCause;
+        rideViewOverride;
+        rideViewNotice;
+        svCoverageNotice;
+        svHasCoverage;
+        svPhaseDelayTimeout;
+        svSlowTimeout;
+        svStartTimeout;
+        svFallbackHoldTimeout;
         constructor() {
             super();
         }
         initView() {
             try {
-                const rideView = this.getRideSettingsDisplay().getRideView();
+                this.tsInit = Date.now();
+                const rideView = this.getRideView();
                 if (rideView === 'sv') {
+                    this.svFlowActive = true;
                     const updateFreq = this.getDefaultUpdateFrequency();
                     const minimalPause = this.getMinimalPause();
                     const bestFreq = this.getBestCaseUpdateFrequency();
                     this.logEvent({ message: 'init streetview', updateFreq, minimalPause, bestFreq });
-                    if (this.waitsForStreetView())
-                        this.armStreetViewStartTimeout();
+                    if (this.hasEagerInitKillSwitch())
+                        this.release('eager');
                 }
                 else if (rideView === 'sat') {
                     if (this.waitsForSatelliteView())
@@ -112,12 +135,12 @@ let GpxDisplayService = (() => {
             };
             const props = {
                 onDisplayEvent: this.onStreetViewEvent.bind(this),
-                displayObserver: this.mapLoaded ? this.getStreetViewObserver() : undefined,
-                displayPosition: this.mapLoaded ? null : this.position,
+                displayObserver: this.svReleased ? this.getStreetViewObserver() : undefined,
+                displayPosition: this.position,
                 sideViews
             };
             if (this.isMobile()) {
-                props.displayPosition = this.mapLoaded ? null : this.getInitialStreetViewPosition();
+                props.displayPosition = this.getInitialStreetViewPosition();
             }
             return props;
         }
@@ -145,10 +168,10 @@ let GpxDisplayService = (() => {
             }
         }
         waitsForStreetView() {
-            return this.getRideSettingsDisplay().getRideView() === 'sv';
+            return this.getRideView() === 'sv';
         }
         waitsForSatelliteView() {
-            return this.getRideSettingsDisplay().getRideView() === 'sat';
+            return this.getRideView() === 'sat';
         }
         getSatelliteViewProps() {
             return {
@@ -164,7 +187,16 @@ let GpxDisplayService = (() => {
             };
         }
         getStartOverlayProps() {
-            const rideView = this.getRideSettingsDisplay().getRideView();
+            if (this.svFlowActive) {
+                const resolved = this.svViewState === 'loaded' || this.svViewState === 'unavailable';
+                return {
+                    mapType: 'Street View',
+                    mapState: resolved ? 'Loaded' : 'Loading',
+                    viewState: this.svViewState,
+                    viewFallbackCause: this.svViewState === 'unavailable' ? this.svFallbackCause : undefined
+                };
+            }
+            const rideView = this.getRideView();
             if (rideView === 'map' || (this.isMobile() && !this.waitsForStreetView() && !this.waitsForSatelliteView())) {
                 return {
                     mapType: this.getRideViewName(),
@@ -178,18 +210,21 @@ let GpxDisplayService = (() => {
             };
         }
         isStartRideCompleted() {
-            const rideView = this.getRideSettingsDisplay().getRideView();
+            if (this.svFlowActive) {
+                return this.mapLoaded;
+            }
+            const rideView = this.getRideView();
             if (rideView === 'map' || (this.isMobile() && !this.waitsForStreetView() && !this.waitsForSatelliteView())) {
                 this.mapLoaded = true;
                 return true;
             }
-            if (this.svStartTimedOut || this.satStartTimedOut)
+            if (this.satStartTimedOut)
                 return true;
             return this.mapLoaded;
         }
         getDisplayProperties(props) {
             let routeProps = super.getDisplayProperties(props);
-            const rideView = this.getRideSettingsDisplay().getRideView();
+            const rideView = this.getRideView();
             if (rideView === 'sv') {
                 routeProps = { ...routeProps, ...this.getStreetViewProps(props) };
             }
@@ -199,16 +234,35 @@ let GpxDisplayService = (() => {
             else {
                 routeProps = { ...routeProps, ...this.getMapViewProps() };
             }
+            const rideViewNotice = this.rideViewNotice;
+            delete this.rideViewNotice;
+            const svCoverageNotice = this.svCoverageNotice;
+            delete this.svCoverageNotice;
+            const svHasCoverage = this.svHasCoverage;
             return {
                 rideView,
+                svInitAllowed: rideView === 'sv' && this.svReleased,
+                rideViewNotice,
+                svCoverageNotice,
+                svHasCoverage,
                 ...routeProps
             };
         }
         getRideView() {
-            return this.getRideSettingsDisplay().getRideView();
+            return this.rideViewOverride ?? this.getRideSettingsDisplay().getRideView();
+        }
+        onRideSettingsChanged(settings = {}) {
+            super.onRideSettingsChanged(settings);
+            if (this.rideViewOverride && settings?.rideView) {
+                delete this.rideViewOverride;
+            }
+            if (settings?.rideView === 'sv' && !this.svReleased) {
+                this.svFlowActive = true;
+                this.release('mid-ride');
+            }
         }
         getRideViewName() {
-            const rideView = this.getRideSettingsDisplay().getRideView();
+            const rideView = this.getRideView();
             const map = {
                 map: 'Map',
                 sv: 'Street View',
@@ -234,48 +288,70 @@ let GpxDisplayService = (() => {
             this.emit('state-update');
         }
         onStreetViewEvent(event, data) {
-            const resetTimeout = () => {
-                if (this.povTimeout) {
-                    clearTimeout(this.povTimeout);
-                    this.povTimeout = undefined;
-                }
-            };
             if (event === 'Loaded') {
+                this.setSvHasCoverage(true);
                 this.mapLoaded = true;
-                this.clearStreetViewStartTimeout();
-                this.emit('state-update');
+                this.resolveStreetViewStart('loaded');
                 this.tsLastSVEvent = Date.now();
             }
+            else if (event === 'NoPanorama') {
+                this.onNoPanorama(data);
+            }
             else if (event === 'Error') {
-                this.mapError = data;
-                this.emit('state-update');
-                this.logEvent({ message: 'street view position update error', error: this.mapError });
-                resetTimeout();
+                this.onStreetViewError(data);
             }
             else if (event === 'pano_changed') {
-                this.logEvent({ message: 'street view panorama changed', panorama: data });
-                this.tsLastSVEvent = Date.now();
-                if (this.isMobile())
-                    this.recordUpdateDuration();
+                this.onPanoChanged(data);
             }
             else if (event === 'pov_changed') {
-                if (this.tsLastPovChanged) {
-                    this.tsLastPovChanged = Date.now();
-                    this.tsLastSVEvent = Date.now();
-                    resetTimeout();
-                    this.povTimeout = setTimeout(() => {
-                        this.povTimeout = undefined;
-                        this.recordUpdateDuration();
-                    }, 100);
-                }
-                else {
-                    this.tsLastPovChanged = Date.now();
-                }
+                this.onPovChanged();
             }
             else if (event === 'status_changed' || event === 'position_changed') {
                 this.tsLastSVEvent = Date.now();
             }
         }
+        onNoPanorama(status) {
+            this.logEvent({ message: 'street view position update error', error: 'NoPanorama' });
+            if (this.svViewState !== 'loaded' && this.svViewState !== 'unavailable') {
+                this.mapLoaded = true;
+                this.resolveStreetViewStart('no-imagery');
+            }
+            this.reportNoCoverage(status);
+        }
+        onStreetViewError(error) {
+            this.mapError = error;
+            this.emit('state-update');
+            this.logEvent({ message: 'street view position update error', error: this.mapError });
+            this.clearPovTimeout();
+            if (this.svViewState !== 'loaded' && this.svViewState !== 'unavailable')
+                this.fallbackToMap('maps-api');
+        }
+        onPanoChanged(panorama) {
+            this.logEvent({ message: 'street view panorama changed', panorama });
+            this.tsLastSVEvent = Date.now();
+            this.setSvHasCoverage(true);
+            if (this.isMobile())
+                this.recordUpdateDuration();
+        }
+        onPovChanged() {
+            if (!this.tsLastPovChanged) {
+                this.tsLastPovChanged = Date.now();
+                return;
+            }
+            this.tsLastPovChanged = Date.now();
+            this.tsLastSVEvent = Date.now();
+            this.clearPovTimeout();
+            this.povTimeout = setTimeout(() => {
+                this.povTimeout = undefined;
+                this.recordUpdateDuration();
+            }, 100);
+        }
+        clearPovTimeout() {
+            if (this.povTimeout) {
+                clearTimeout(this.povTimeout);
+                this.povTimeout = undefined;
+            }
+        }
         recordUpdateDuration() {
             if (!this.tsPrevSVUpdate)
                 return;
@@ -288,27 +364,132 @@ let GpxDisplayService = (() => {
             this.updateDurations.push(duration);
             this.logEvent({ message: 'street view position update confirmed', duration });
         }
-        armStreetViewStartTimeout() {
-            this.clearStreetViewStartTimeout();
+        release(trigger) {
+            if (this.svReleased)
+                return;
+            this.svReleased = true;
+            this.svInitTrigger = trigger;
+            this.tsSvReleased = Date.now();
+            const svInitDelay = this.tsSvReleased - (this.tsInit ?? this.tsSvReleased);
+            this.logEvent({ message: 'streetview init released', svInitTrigger: trigger, svInitDelay });
+            this.armStreetViewPhaseTimers();
+            this.emit('state-update');
+        }
+        armStreetViewPhaseTimers() {
+            this.clearStreetViewPhaseTimers();
+            const phaseDelay = this.getStreetViewPhaseDelay();
+            this.svPhaseDelayTimeout = setTimeout(() => {
+                this.svPhaseDelayTimeout = undefined;
+                if (this.svViewState === 'waiting') {
+                    this.svViewState = 'loading';
+                    this.svPhaseWasVisible = true;
+                    this.emit('state-update');
+                }
+            }, phaseDelay);
+            const slowThreshold = this.getStreetViewSlowThreshold();
+            this.svSlowTimeout = setTimeout(() => {
+                this.svSlowTimeout = undefined;
+                if (this.svViewState === 'waiting' || this.svViewState === 'loading') {
+                    this.svViewState = 'slow';
+                    this.svPhaseWasVisible = true;
+                    this.emit('state-update');
+                }
+            }, slowThreshold);
             const timeout = this.getStreetViewStartTimeout();
             this.svStartTimeout = setTimeout(() => {
                 this.svStartTimeout = undefined;
-                if (this.mapLoaded)
-                    return;
-                this.svStartTimedOut = true;
-                this.logEvent({ message: 'street view start timeout', timeout });
-                this.emit('state-update');
+                if (this.svViewState !== 'loaded' && this.svViewState !== 'unavailable') {
+                    this.logEvent({ message: 'street view start timeout', timeout, svInitTrigger: this.svInitTrigger });
+                    this.fallbackToMap('timeout');
+                }
             }, timeout);
         }
-        clearStreetViewStartTimeout() {
+        clearStreetViewPhaseTimers() {
+            if (this.svPhaseDelayTimeout) {
+                clearTimeout(this.svPhaseDelayTimeout);
+                this.svPhaseDelayTimeout = undefined;
+            }
+            if (this.svSlowTimeout) {
+                clearTimeout(this.svSlowTimeout);
+                this.svSlowTimeout = undefined;
+            }
             if (this.svStartTimeout) {
                 clearTimeout(this.svStartTimeout);
                 this.svStartTimeout = undefined;
             }
         }
+        resolveStreetViewStart(svStartResult) {
+            if (this.svViewState === 'loaded' || this.svViewState === 'unavailable')
+                return;
+            this.clearStreetViewPhaseTimers();
+            this.svViewState = 'loaded';
+            this.logEvent({ message: 'streetview start resolved', svStartResult, elapsed: this.getSvElapsed(), svPhaseVisible: this.svPhaseWasVisible });
+            this.emit('state-update');
+        }
+        setSvHasCoverage(value) {
+            if (this.svHasCoverage === value)
+                return;
+            this.svHasCoverage = value;
+            this.emit('state-update');
+        }
+        reportNoCoverage(status) {
+            this.setSvHasCoverage(false);
+            this.svCoverageNotice = { ts: Date.now() };
+            this.logEvent({ message: 'streetview no coverage', status });
+            this.emit('state-update');
+        }
+        fallbackToMap(cause) {
+            if (this.svViewState === 'loaded' || this.svViewState === 'unavailable')
+                return;
+            this.clearStreetViewPhaseTimers();
+            this.svViewState = 'unavailable';
+            this.svFallbackCause = cause;
+            this.rideViewOverride = 'map';
+            const svStartResult = cause === 'maps-api' ? 'maps-api' : cause;
+            this.logEvent({ message: 'streetview start resolved', svStartResult, elapsed: this.getSvElapsed(), svPhaseVisible: this.svPhaseWasVisible });
+            if (cause === 'user') {
+                this.mapLoaded = true;
+                this.emit('state-update');
+                return;
+            }
+            this.rideViewNotice = { cause };
+            this.emit('state-update');
+            this.svFallbackHoldTimeout = setTimeout(() => {
+                this.svFallbackHoldTimeout = undefined;
+                this.mapLoaded = true;
+                this.emit('state-update');
+            }, this.getStreetViewFallbackHold());
+        }
+        getSvElapsed() {
+            return Date.now() - (this.tsSvReleased ?? this.tsInit ?? Date.now());
+        }
+        startWithMapFallback() {
+            this.fallbackToMap('user');
+        }
+        hasEagerInitKillSwitch() {
+            try {
+                return this.getAppState().hasFeature('SV_EAGER_INIT');
+            }
+            catch {
+                return false;
+            }
+        }
+        getStreetViewPhaseDelay() {
+            return this.getNumSetting('SV_PHASE_DELAY') ?? SV_PHASE_DELAY;
+        }
+        getStreetViewSlowThreshold() {
+            return this.getNumSetting('SV_SLOW_THRESHOLD') ?? SV_SLOW_THRESHOLD;
+        }
+        getStreetViewFallbackHold() {
+            return this.getNumSetting('SV_FALLBACK_HOLD') ?? SV_FALLBACK_HOLD;
+        }
         getStreetViewStartTimeout() {
             return this.getNumSetting('SV_START_TIMEOUT') ?? SV_START_TIMEOUT;
         }
+        onStartDevicesReady() {
+            if (this.getRideView() === 'sv' && !this.svReleased)
+                this.release('control-ready');
+        }
         armSatelliteViewStartTimeout() {
             this.clearSatelliteViewStartTimeout();
             const timeout = this.getSatelliteViewStartTimeout();
@@ -331,13 +512,18 @@ let GpxDisplayService = (() => {
             return this.getNumSetting('SAT_START_TIMEOUT') ?? SAT_START_TIMEOUT;
         }
         onStarted() {
-            this.clearStreetViewStartTimeout();
+            if (this.getRideView() === 'sv' && !this.svReleased)
+                this.release('start-completed');
             this.clearSatelliteViewStartTimeout();
             super.onStarted();
         }
         async stop() {
-            this.clearStreetViewStartTimeout();
+            this.clearStreetViewPhaseTimers();
             this.clearSatelliteViewStartTimeout();
+            if (this.svFallbackHoldTimeout) {
+                clearTimeout(this.svFallbackHoldTimeout);
+                this.svFallbackHoldTimeout = undefined;
+            }
             return super.stop();
         }
         getStreetViewObserver() {
@@ -359,7 +545,7 @@ let GpxDisplayService = (() => {
         }
         onPositionUpdate(state) {
             const { route, position } = state ?? {};
-            const rideView = this.getRideSettingsDisplay().getRideView();
+            const rideView = this.getRideView();
             if (rideView === 'sv') {
                 const sincePrev = Date.now() - (this.tsPrevSVUpdate ?? 0);
                 if (sincePrev > this.getStreetViewUpdateDelay() - 25) {
@@ -418,6 +604,9 @@ let GpxDisplayService = (() => {
         getRideSettingsDisplay() {
             return (0, display_1.useRideSettingsDisplay)();
         }
+        getAppState() {
+            return (0, appstate_1.useAppState)();
+        }
     };
 })();
 exports.GpxDisplayService = GpxDisplayService;

package/lib/cjs/routes/library/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toRouteImportError = exports.mapErrorToImportCode = exports.RouteImportError = void 0;
+exports.toRouteImportError = exports.mapErrorToImportCode = exports.DuplicateRouteError = exports.RouteImportError = void 0;
 class RouteImportError extends Error {
     code;
     missingExt;
@@ -18,6 +18,15 @@ class RouteImportError extends Error {
     }
 }
 exports.RouteImportError = RouteImportError;
+class DuplicateRouteError extends Error {
+    duplicateOf;
+    constructor(duplicateOf) {
+        super(`Duplicate of ${duplicateOf}`);
+        this.name = 'DuplicateRouteError';
+        this.duplicateOf = duplicateOf;
+    }
+}
+exports.DuplicateRouteError = DuplicateRouteError;
 const mapErrorToImportCode = (err, scope) => {
     if (err instanceof RouteImportError)
         return err.code;