@coolon/angular-ui-powerups 0.0.115 → 0.0.117

package/bundles/coolon-angular-ui-powerups.umd.js

@@ -3488,6 +3488,7 @@
             var _this = this;
             pectin.assert.isNil(this.visit);
             this.visit = visit;
+            // DebugContext.get(this.visit).tag(`${this.placeDefinition.component.name}.visit`);
             this.placeDefinition.getVisitParameterDefs().forEach((/**
              * @param {?} parameterDef
              * @return {?}
@@ -3968,6 +3969,7 @@
             var _this = _super.call(this) || this;
             _this.context = context;
             _this._visits = new Map();
+            _this.debugPropertyKeys = [];
             return _this;
         }
         Object.defineProperty(NavigationState.prototype, "name", {
@@ -4188,14 +4190,18 @@
         function (event) {
             /** @type {?} */
             var popstate = event.navigationTrigger === 'popstate';
-            return popstate ?
-                this.interactionService.isActive() ?
-                    new NavigationState.InteractionPopStateTransition(this.context, this.currentRouterUrl()) :
-                    new NavigationState.PopStateTransition(this.context, this.currentRouterUrl())
-                :
-                    this.interactionService.isActive() ?
-                        new NavigationState.InteractionTransition(this.context, this.currentRouterUrl()) :
-                        new NavigationState.NavigationTransition(this.context, this.currentRouterUrl());
+            /** @type {?} */
+            var inInteraction = this.interactionService.isActive();
+            if (popstate) {
+                return inInteraction ?
+                    new NavigationState.LeavingInteractionAfterPopStateTransition(this.context, this.currentRouterUrl(), event.url) :
+                    new NavigationState.PopStateTransition(this.context, this.currentRouterUrl(), event.url);
+            }
+            else {
+                return inInteraction ?
+                    new NavigationState.StartingInteractionTransition(this.context, this.currentRouterUrl()) :
+                    new NavigationState.NavigationTransition(this.context, this.currentRouterUrl());
+            }
         };
         /**
          * @protected
@@ -4210,17 +4216,36 @@
                 new NavigationState.IdleDuringInteraction(this.context, this.currentRouterUrl()) :
                 new NavigationState.Idle(this.context);
         };
+        //
+        //
         /**
          * @param {?} url
          * @return {?}
          */
-        NavigationState.prototype.resetBrowserLocation = /**
+        NavigationState.prototype.resetBrowserLocation = 
+        //
+        /**
          * @param {?} url
          * @return {?}
          */
         function (url) {
             this.placeRouter.resetBrowserLocation(url);
         };
+        /**
+         * @param {?} event
+         * @param {?=} reason
+         * @return {?}
+         */
+        NavigationState.prototype.ignore = /**
+         * @param {?} event
+         * @param {?=} reason
+         * @return {?}
+         */
+        function (event, reason) {
+            reason = reason ? " -> " + reason : '';
+            pectin.Logger.get(this).info("Ignoring router event" + reason + ": " + event.constructor.name + " -> " + event.url + " :: " + this.toString());
+            return this;
+        };
         /**
          * @return {?}
          */
@@ -4228,7 +4253,27 @@
          * @return {?}
          */
         function () {
-            return this.constructor.name;
+            return this.constructor.name + "(" + this.debugState() + ")";
+        };
+        /**
+         * @protected
+         * @param {?=} properties
+         * @return {?}
+         */
+        NavigationState.prototype.debugState = /**
+         * @protected
+         * @param {?=} properties
+         * @return {?}
+         */
+        function (properties) {
+            var _this = this;
+            return (properties || this.debugPropertyKeys).map((/**
+             * @param {?} p
+             * @return {?}
+             */
+            function (p) {
+                return p + ": " + _this[p];
+            })).join(', ');
         };
         return NavigationState;
     }(pectin.GarbageCollector));
@@ -4244,6 +4289,8 @@
         exports.NavigationState.prototype.startingUrl;
         /** @type {?} */
         exports.NavigationState.prototype.isPopState;
+        /** @type {?} */
+        exports.NavigationState.prototype.debugPropertyKeys;
         /**
          * @type {?}
          * @protected
@@ -4309,7 +4356,7 @@
                 }
                 if (this.placeRouter.hasActiveInteractionIds(event.url)) {
                     pectin.Logger.get(this).info("navigation started with interaction outlet -> " + event.url);
-                    return new InteractionTransition(this.context, event.url);
+                    return new StartingInteractionTransition(this.context, event.url);
                 }
                 else {
                     return this.createTransitionStateFor(event);
@@ -4402,14 +4449,14 @@
                 return new Idle(this.context);
             };
             /**
-             * @param {?} locationTriggerUrl
+             * @param {?} newUrl
              * @return {?}
              */
             AbstractNavigationTransition.prototype.onBackClickedDuringNavigationInteraction = /**
-             * @param {?} locationTriggerUrl
+             * @param {?} newUrl
              * @return {?}
              */
-            function (locationTriggerUrl) {
+            function (newUrl) {
                 pectin.Logger.get(this).info("back button pressed during navigation session interaction promise");
                 // detach the interaction from the session so it doesn't get disposed until the activity has completed.
                 /** @type {?} */
@@ -4417,25 +4464,22 @@
                 var when = pectin.Dsl.disposeWith(navigationInteraction).when;
                 // TODO: I need to make the exclusive interaction context disallow nested activities or
                 //       that would mess things up entirely. Or, can I do a context.abortAll().then(..)
+                pectin.Logger.get(this).info('cancelling current navigation activity..');
                 navigationInteraction.cancelActiveActivity().then((/**
                  * @return {?}
                  */
                 function () {
                     navigationInteraction.dispose();
                 }));
-                return new CancelledDuringNavigationInteraction(this.context, this.startingUrl, this.isPopState, locationTriggerUrl);
+                return this.createNavigationInteractionCancelledState(newUrl);
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} component
              * @param {?} currentUrl
              * @param {?} nextUrl
              * @return {?}
              */
-            AbstractNavigationTransition.prototype.canDeactivatePlace = 
-            // @Trace()
-            /**
+            AbstractNavigationTransition.prototype.canDeactivatePlace = /**
              * @param {?} component
              * @param {?} currentUrl
              * @param {?} nextUrl
@@ -4457,11 +4501,11 @@
                 });
             };
             /**
-             * @private
+             * @protected
              * @return {?}
              */
             AbstractNavigationTransition.prototype.detachInteractionContext = /**
-             * @private
+             * @protected
              * @return {?}
              */
             function () {
@@ -4488,12 +4532,19 @@
             AbstractNavigationTransition.prototype._interactionContext;
             /** @type {?} */
             AbstractNavigationTransition.prototype.startingUrl;
+            /**
+             * @abstract
+             * @param {?} newUrl
+             * @return {?}
+             */
+            AbstractNavigationTransition.prototype.createNavigationInteractionCancelledState = function (newUrl) { };
         }
         var NavigationTransition = /** @class */ (function (_super) {
             __extends(NavigationTransition, _super);
             function NavigationTransition() {
                 var _this = _super !== null && _super.apply(this, arguments) || this;
                 _this.isPopState = false;
+                _this.debugPropertyKeys = ['startingUrl'];
                 return _this;
             }
             /**
@@ -4520,13 +4571,15 @@
                 return new Idle(this.context);
             };
             /**
+             * @param {?} newUrl
              * @return {?}
              */
-            NavigationTransition.prototype.toString = /**
+            NavigationTransition.prototype.createNavigationInteractionCancelledState = /**
+             * @param {?} newUrl
              * @return {?}
              */
-            function () {
-                return this.constructor.name + "(startingUrl: " + this.startingUrl + ")";
+            function (newUrl) {
+                return new LinkTriggeredNavigationInteractionCancelled(this.context, this.startingUrl, newUrl);
             };
             return NavigationTransition;
         }(AbstractNavigationTransition));
@@ -4534,12 +4587,16 @@
         if (false) {
             /** @type {?} */
             NavigationTransition.prototype.isPopState;
+            /** @type {?} */
+            NavigationTransition.prototype.debugPropertyKeys;
         }
         var PopStateTransition = /** @class */ (function (_super) {
             __extends(PopStateTransition, _super);
-            function PopStateTransition() {
-                var _this = _super !== null && _super.apply(this, arguments) || this;
+            function PopStateTransition(context, startingUrl, poppedHistoryUrl) {
+                var _this = _super.call(this, context, startingUrl) || this;
+                _this.poppedHistoryUrl = poppedHistoryUrl;
                 _this.isPopState = true;
+                _this.debugPropertyKeys = ['startingUrl', 'poppedHistoryUrl'];
                 return _this;
             }
             /**
@@ -4554,7 +4611,8 @@
                 // Angular doesn't preserve the url when a guard cancels the back button.
                 // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
                 pectin.Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
-                this.resetBrowserLocation(this.startingUrl);
+                this.resetBrowserLocation(this.poppedHistoryUrl); // put the popped history item back in.
+                this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
                 return new Idle(this.context);
             };
             /**
@@ -4571,24 +4629,75 @@
                     // Angular doesn't preserve the url when a guard cancels the back button.
                     // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
                     pectin.Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
-                    this.resetBrowserLocation(this.startingUrl);
+                    this.resetBrowserLocation(this.poppedHistoryUrl); // put the popped history item back in.
+                    this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
                 }
                 return new Idle(this.context);
             };
+            /**
+             * @param {?} locationTriggerUrl
+             * @return {?}
+             */
+            PopStateTransition.prototype.createNavigationInteractionCancelledState = /**
+             * @param {?} locationTriggerUrl
+             * @return {?}
+             */
+            function (locationTriggerUrl) {
+                return new PopStateTriggeredNavigationInteractionCancelled(this.context, this.startingUrl, locationTriggerUrl, this.poppedHistoryUrl);
+            };
             return PopStateTransition;
         }(AbstractNavigationTransition));
         NavigationState.PopStateTransition = PopStateTransition;
         if (false) {
             /** @type {?} */
             PopStateTransition.prototype.isPopState;
+            /** @type {?} */
+            PopStateTransition.prototype.debugPropertyKeys;
+            /** @type {?} */
+            PopStateTransition.prototype.poppedHistoryUrl;
         }
-        var IdleDuringInteraction = /** @class */ (function (_super) {
+        /**
+         * @abstract
+         */
+        var /**
+         * @abstract
+         */
+        AbstractInteractionTransition = /** @class */ (function (_super) {
+            __extends(AbstractInteractionTransition, _super);
+            function AbstractInteractionTransition(context, startingUrl) {
+                var _this = _super.call(this, context, startingUrl) || this;
+                _this.startingUrl = startingUrl;
+                _this.isTransitional = true;
+                return _this;
+            }
+            return AbstractInteractionTransition;
+        }(AbstractNavigationTransition));
+        NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
+        if (false) {
+            /** @type {?} */
+            AbstractInteractionTransition.prototype.isTransitional;
+            /** @type {?} */
+            AbstractInteractionTransition.prototype.startingUrl;
+        }
+        // The following states exist to handle all events while any kind of navigation is in progress.  That way all other states can
+        // happily ignore interaction contexts.
+        /**
+         * This is the non transitional (i.e. rest) state that is used whenever an interaction context is active.
+         */
+        var 
+        // The following states exist to handle all events while any kind of navigation is in progress.  That way all other states can
+        // happily ignore interaction contexts.
+        /**
+         * This is the non transitional (i.e. rest) state that is used whenever an interaction context is active.
+         */
+        IdleDuringInteraction = /** @class */ (function (_super) {
             __extends(IdleDuringInteraction, _super);
             function IdleDuringInteraction(context, startingUrl) {
                 var _this = _super.call(this, context) || this;
                 _this.startingUrl = startingUrl;
                 _this.isTransitional = false;
                 _this.isPopState = false;
+                _this.debugPropertyKeys = ['startingUrl'];
                 return _this;
             }
             /**
@@ -4602,40 +4711,34 @@
              * @return {?}
              */
             function (visit, initialUrl) {
+                // we're in an interaction and the user clicked back
                 /** @type {?} */
-                var navigationTransition = new InteractionTransition(this.context, initialUrl);
+                var navigationTransition = new StartingInteractionTransition(this.context, initialUrl);
                 navigationTransition.storeVisit(visit);
                 return navigationTransition;
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            IdleDuringInteraction.prototype.onRouterStarted = 
-            // @Trace()
-            /**
+            IdleDuringInteraction.prototype.onRouterStarted = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
-                return new InteractionTransition(this.context, event.url);
+                return new StartingInteractionTransition(this.context, event.url);
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            IdleDuringInteraction.prototype.onPopState = 
-            // @Trace()
-            /**
+            IdleDuringInteraction.prototype.onPopState = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
-                return new InteractionPopStateTransition(this.context, event.url);
+                // we're in an interaction and the user clicked back
+                return new LeavingInteractionAfterPopStateTransition(this.context, event.url, event.url);
             };
             return IdleDuringInteraction;
         }(NavigationState));
@@ -4646,55 +4749,34 @@
             /** @type {?} */
             IdleDuringInteraction.prototype.isPopState;
             /** @type {?} */
-            IdleDuringInteraction.prototype.startingUrl;
-        }
-        /**
-         * @abstract
-         */
-        var /**
-         * @abstract
-         */
-        AbstractInteractionTransition = /** @class */ (function (_super) {
-            __extends(AbstractInteractionTransition, _super);
-            function AbstractInteractionTransition(context, startingUrl) {
-                var _this = _super.call(this, context, startingUrl) || this;
-                _this.startingUrl = startingUrl;
-                _this.isTransitional = true;
-                return _this;
-            }
-            return AbstractInteractionTransition;
-        }(AbstractNavigationTransition));
-        NavigationState.AbstractInteractionTransition = AbstractInteractionTransition;
-        if (false) {
-            /** @type {?} */
-            AbstractInteractionTransition.prototype.isTransitional;
+            IdleDuringInteraction.prototype.debugPropertyKeys;
             /** @type {?} */
-            AbstractInteractionTransition.prototype.startingUrl;
+            IdleDuringInteraction.prototype.startingUrl;
         }
         /**
          * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
          * happily ignore interaction contexts.
+         * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+         *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
          */
         var /**
          * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
          * happily ignore interaction contexts.
+         * NOTE: This state is activated when ever an interaction is started.  It might be better to split it into
+         *       different states for different scenarios, e.g. starting model, starting model during route guard etc.
          */
-        InteractionTransition = /** @class */ (function (_super) {
-            __extends(InteractionTransition, _super);
-            function InteractionTransition() {
+        StartingInteractionTransition = /** @class */ (function (_super) {
+            __extends(StartingInteractionTransition, _super);
+            function StartingInteractionTransition() {
                 var _this = _super !== null && _super.apply(this, arguments) || this;
                 _this.isPopState = false;
                 return _this;
             }
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            InteractionTransition.prototype.onRouterCancelled = 
-            // @Trace()
-            /**
+            StartingInteractionTransition.prototype.onRouterCancelled = /**
              * @param {?} event
              * @return {?}
              */
@@ -4709,15 +4791,11 @@
                     return new Idle(this.context);
                 }
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            InteractionTransition.prototype.onRouterError = 
-            // @Trace()
-            /**
+            StartingInteractionTransition.prototype.onRouterError = /**
              * @param {?} event
              * @return {?}
              */
@@ -4725,15 +4803,11 @@
                 // navigation was aborted.
                 return new IdleDuringInteraction(this.context, this.startingUrl);
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            InteractionTransition.prototype.onRouterEnd = 
-            // @Trace()
-            /**
+            StartingInteractionTransition.prototype.onRouterEnd = /**
              * @param {?} event
              * @return {?}
              */
@@ -4745,12 +4819,163 @@
                     return new Idle(this.context);
                 }
             };
-            return InteractionTransition;
+            /**
+             * @param {?} locationTriggerUrl
+             * @return {?}
+             */
+            StartingInteractionTransition.prototype.createNavigationInteractionCancelledState = /**
+             * @param {?} locationTriggerUrl
+             * @return {?}
+             */
+            function (locationTriggerUrl) {
+                return new LeavingInteractionTransitionCancelled(this.context, this.startingUrl, locationTriggerUrl);
+            };
+            return StartingInteractionTransition;
         }(AbstractInteractionTransition));
-        NavigationState.InteractionTransition = InteractionTransition;
+        NavigationState.StartingInteractionTransition = StartingInteractionTransition;
+        if (false) {
+            /** @type {?} */
+            StartingInteractionTransition.prototype.isPopState;
+        }
+        /**
+         * The sequence of router events are:
+         * Error -> url = url of navigation link
+         * End
+         * onPopState url = current intereaction url sans the query params
+         * Cancel url == same as above.
+         */
+        var /**
+         * The sequence of router events are:
+         * Error -> url = url of navigation link
+         * End
+         * onPopState url = current intereaction url sans the query params
+         * Cancel url == same as above.
+         */
+        LeavingInteractionTransitionCancelled = /** @class */ (function (_super) {
+            __extends(LeavingInteractionTransitionCancelled, _super);
+            function LeavingInteractionTransitionCancelled(context, startingUrl, locationChangeTriggerUrl) {
+                var _this = _super.call(this, context) || this;
+                _this.startingUrl = startingUrl;
+                _this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+                _this.isPopState = false;
+                _this.firstCancelHandled = false;
+                _this.popStateHandled = false;
+                _this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+                return _this;
+            }
+            Object.defineProperty(LeavingInteractionTransitionCancelled.prototype, "isTransitional", {
+                get: /**
+                 * @return {?}
+                 */
+                function () {
+                    return true;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.onRouterStarted = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.onRouterCancelled = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                // Angular doesn't preserve the url when a guard cancels the back button.
+                // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                pectin.Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+                if (this.interactionService.isActive()) {
+                    /** @type {?} */
+                    var interactionIds = this.interactionService.activeInteractionContextIds.value;
+                    this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+                }
+                else {
+                    this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
+                }
+                return this.createIdleState();
+            };
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.onRouterEnd = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.onRouterError = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.onPopState = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} component
+             * @param {?} currentUrl
+             * @param {?} nextUrl
+             * @return {?}
+             */
+            LeavingInteractionTransitionCancelled.prototype.canDeactivatePlace = /**
+             * @param {?} component
+             * @param {?} currentUrl
+             * @param {?} nextUrl
+             * @return {?}
+             */
+            function (component, currentUrl, nextUrl) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, false];
+                    });
+                });
+            };
+            return LeavingInteractionTransitionCancelled;
+        }(NavigationState));
+        NavigationState.LeavingInteractionTransitionCancelled = LeavingInteractionTransitionCancelled;
         if (false) {
             /** @type {?} */
-            InteractionTransition.prototype.isPopState;
+            LeavingInteractionTransitionCancelled.prototype.isPopState;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.firstCancelHandled;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.popStateHandled;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.popStateEventUrl;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.debugPropertyKeys;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.startingUrl;
+            /** @type {?} */
+            LeavingInteractionTransitionCancelled.prototype.locationChangeTriggerUrl;
         }
         /**
          * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
@@ -4760,22 +4985,19 @@
          * This state exists to handle all events while any kind of navigation is in progress.  That way all other states can
          * happily ignore interaction contexts.
          */
-        InteractionPopStateTransition = /** @class */ (function (_super) {
-            __extends(InteractionPopStateTransition, _super);
-            function InteractionPopStateTransition() {
-                var _this = _super !== null && _super.apply(this, arguments) || this;
+        LeavingInteractionAfterPopStateTransition = /** @class */ (function (_super) {
+            __extends(LeavingInteractionAfterPopStateTransition, _super);
+            function LeavingInteractionAfterPopStateTransition(context, startingUrl, poppedHistoryUrl) {
+                var _this = _super.call(this, context, startingUrl) || this;
+                _this.poppedHistoryUrl = poppedHistoryUrl;
                 _this.isPopState = true;
                 return _this;
             }
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            InteractionPopStateTransition.prototype.onRouterCancelled = 
-            // @Trace()
-            /**
+            LeavingInteractionAfterPopStateTransition.prototype.onRouterCancelled = /**
              * @param {?} event
              * @return {?}
              */
@@ -4790,15 +5012,11 @@
                     return new Idle(this.context);
                 }
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            InteractionPopStateTransition.prototype.onRouterEnd = 
-            // @Trace()
-            /**
+            LeavingInteractionAfterPopStateTransition.prototype.onRouterEnd = /**
              * @param {?} event
              * @return {?}
              */
@@ -4810,25 +5028,219 @@
                     return new Idle(this.context);
                 }
             };
-            return InteractionPopStateTransition;
+            /**
+             * @param {?} newUrl
+             * @return {?}
+             */
+            LeavingInteractionAfterPopStateTransition.prototype.createNavigationInteractionCancelledState = /**
+             * @param {?} newUrl
+             * @return {?}
+             */
+            function (newUrl) {
+                return this.illegalTransition("Leaving interaction after pop-state should't block so should never see a back button click");
+            };
+            return LeavingInteractionAfterPopStateTransition;
         }(AbstractInteractionTransition));
-        NavigationState.InteractionPopStateTransition = InteractionPopStateTransition;
+        NavigationState.LeavingInteractionAfterPopStateTransition = LeavingInteractionAfterPopStateTransition;
         if (false) {
             /** @type {?} */
-            InteractionPopStateTransition.prototype.isPopState;
+            LeavingInteractionAfterPopStateTransition.prototype.isPopState;
+            /** @type {?} */
+            LeavingInteractionAfterPopStateTransition.prototype.poppedHistoryUrl;
         }
-        var CancelledDuringNavigationInteraction = /** @class */ (function (_super) {
-            __extends(CancelledDuringNavigationInteraction, _super);
-            function CancelledDuringNavigationInteraction(context, startingUrl, startingEventWasAPopState, locationChangeTriggerUrl) {
+        // See LeavingInteractionAfterPopStateTransition.createNavigationInteractionCancelledState(...) above.
+        //
+        // export class LeavingInteractionAfterPopStateCancelled extends NavigationState {
+        //
+        //   readonly isPopState = false;
+        //   firstCancelHandled = false;
+        //   popStateHandled = false;
+        //   popStateEventUrl: string;
+        //   debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+        //
+        //   constructor(context: Context,
+        //               readonly startingUrl: string,
+        //               readonly locationChangeTriggerUrl: string,
+        //               readonly poppedHistoryUrl: string) {
+        //     super(context);
+        //   }
+        //
+        //   get isTransitional() {
+        //     return true;
+        //   }
+        //
+        //   onRouterStarted(event: NavigationStart): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onRouterCancelled(event: NavigationCancel): NavigationState {
+        //
+        //     // if (this.firstCancelHandled && this.popStateHandled) {
+        //     //   // Angular doesn't preserve the url when a guard cancels the back button.
+        //     //   // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+        //     //   Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+        //     //   this.resetBrowserLocation(this.locationChangeTriggerUrl); // put the second back click one back in.
+        //     //   this.resetBrowserLocation(this.poppedHistoryUrl); // put the first back click one back in.
+        //     //   if (this.interactionService.isActive()) {
+        //     //     const interactionIds = this.interactionService.activeInteractionContextIds.value;
+        //     //     this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+        //     //   } else {
+        //     //     this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
+        //     //   }
+        //     //   return this.createIdleState();
+        //     // } else {
+        //     //   this.firstCancelHandled = true;
+        //     return this.ignore(event);
+        //     // }
+        //   }
+        //
+        //
+        //   onRouterEnd(event: NavigationEnd): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onRouterError(event: NavigationError): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onPopState(event: NavigationStart): NavigationState {
+        //     // this.popStateHandled = true;
+        //     // this.popStateEventUrl = event.url;
+        //     return this.ignore(event);
+        //   }
+        //
+        //   async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {
+        //     return false;
+        //   }
+        // }
+        /**
+         * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.
+         * The routing event sequence is different depending on the link that was clicked.
+         *
+         * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+         *
+         * -> Idle -> NavigationTransition
+         * -> confirm dialog shown.
+         * -> click back
+         * -> NavigationCancel -> clickedLinkUrl === cancel.url
+         * -> NavigationEnd
+         *
+         * Otherwise if the link is different from teh history location then the sequence is:
+         *
+         * -> Idle -> NavigationTransition
+         * -> confirm dialog shown.
+         * -> click back
+         * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+         * -> NavigationEnd
+         * -> PopState
+         * -> NavigationCancel
+         */
+        var 
+        // See LeavingInteractionAfterPopStateTransition.createNavigationInteractionCancelledState(...) above.
+        //
+        // export class LeavingInteractionAfterPopStateCancelled extends NavigationState {
+        //
+        //   readonly isPopState = false;
+        //   firstCancelHandled = false;
+        //   popStateHandled = false;
+        //   popStateEventUrl: string;
+        //   debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+        //
+        //   constructor(context: Context,
+        //               readonly startingUrl: string,
+        //               readonly locationChangeTriggerUrl: string,
+        //               readonly poppedHistoryUrl: string) {
+        //     super(context);
+        //   }
+        //
+        //   get isTransitional() {
+        //     return true;
+        //   }
+        //
+        //   onRouterStarted(event: NavigationStart): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onRouterCancelled(event: NavigationCancel): NavigationState {
+        //
+        //     // if (this.firstCancelHandled && this.popStateHandled) {
+        //     //   // Angular doesn't preserve the url when a guard cancels the back button.
+        //     //   // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+        //     //   Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+        //     //   this.resetBrowserLocation(this.locationChangeTriggerUrl); // put the second back click one back in.
+        //     //   this.resetBrowserLocation(this.poppedHistoryUrl); // put the first back click one back in.
+        //     //   if (this.interactionService.isActive()) {
+        //     //     const interactionIds = this.interactionService.activeInteractionContextIds.value;
+        //     //     this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+        //     //   } else {
+        //     //     this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
+        //     //   }
+        //     //   return this.createIdleState();
+        //     // } else {
+        //     //   this.firstCancelHandled = true;
+        //     return this.ignore(event);
+        //     // }
+        //   }
+        //
+        //
+        //   onRouterEnd(event: NavigationEnd): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onRouterError(event: NavigationError): NavigationState {
+        //     return this.ignore(event);
+        //   }
+        //
+        //
+        //   onPopState(event: NavigationStart): NavigationState {
+        //     // this.popStateHandled = true;
+        //     // this.popStateEventUrl = event.url;
+        //     return this.ignore(event);
+        //   }
+        //
+        //   async canDeactivatePlace(component: PlaceComponent, currentUrl: UrlSnapshot, nextUrl: UrlSnapshot): Promise<boolean | UrlSnapshot> {
+        //     return false;
+        //   }
+        // }
+        /**
+         * This state handles the scenario where a link navigation triggered an interaction and the user clicked back a to cancel it.
+         * The routing event sequence is different depending on the link that was clicked.
+         *
+         * If the link was the same as the previous history location (i.e. they've gone back via a link rather than clicking back) then the sequence is:
+         *
+         * -> Idle -> NavigationTransition
+         * -> confirm dialog shown.
+         * -> click back
+         * -> NavigationCancel -> clickedLinkUrl === cancel.url
+         * -> NavigationEnd
+         *
+         * Otherwise if the link is different from teh history location then the sequence is:
+         *
+         * -> Idle -> NavigationTransition
+         * -> confirm dialog shown.
+         * -> click back
+         * -> NavigationCancel -> clickedLinkUrl !== cancel.url
+         * -> NavigationEnd
+         * -> PopState
+         * -> NavigationCancel
+         */
+        LinkTriggeredNavigationInteractionCancelled = /** @class */ (function (_super) {
+            __extends(LinkTriggeredNavigationInteractionCancelled, _super);
+            function LinkTriggeredNavigationInteractionCancelled(context, startingUrl, clickedLinkUrl) {
                 var _this = _super.call(this, context) || this;
                 _this.startingUrl = startingUrl;
-                _this.startingEventWasAPopState = startingEventWasAPopState;
-                _this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+                _this.clickedLinkUrl = clickedLinkUrl;
                 _this.isPopState = false;
-                _this.gotPopStateWithLeavingUrl = false;
+                _this.clickedLinkMatchedBackButtonUrl = false;
+                _this.debugPropertyKeys = ['idle', 'startingUrl', 'clickedLinkUrl', 'firstCancelEventUrl', 'clickedLinkMatchedBackButtonUrl', 'popStateEventUrl'];
                 return _this;
             }
-            Object.defineProperty(CancelledDuringNavigationInteraction.prototype, "isTransitional", {
+            Object.defineProperty(LinkTriggeredNavigationInteractionCancelled.prototype, "isTransitional", {
                 get: /**
                  * @return {?}
                  */
@@ -4842,53 +5254,56 @@
              * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.onRouterStarted = /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.onRouterStarted = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
                 return this.ignore(event);
             };
-            // @Trace()
-            // @Trace()
             /**
              * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.onRouterCancelled = 
-            // @Trace()
-            /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.onRouterCancelled = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
-                // Depending on the state of the router and what was done we get a different
-                // sequence of events.
-                // If the navigation change was triggered by clicking a link we'll get a cancel with the locationChangeTriggerUrl as the final event.
-                // If the navigation change was triggered with a pop state then we'll get an onPopState with the locationChangeTriggerUrl but no cancel event with it.
-                if (this.gotPopStateWithLeavingUrl && this.interactionService.isActive()) {
-                    /** @type {?} */
-                    var interactionIds = this.interactionService.activeInteractionContextIds.value;
-                    this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+                // TODO: should really split this into two sub states in the first cancel event.
+                if (!this.firstCancelEventUrl) {
+                    this.firstCancelEventUrl = event.url;
+                    this.clickedLinkMatchedBackButtonUrl = event.url === this.clickedLinkUrl;
+                    return this.ignore(event);
+                }
+                else {
+                    // we wait for our popped state to come in.
+                    if (!this.clickedLinkMatchedBackButtonUrl && this.popStateEventUrl) {
+                        return this.finaliseRouting();
+                    }
                 }
-                return this.gotPopStateWithLeavingUrl || this.locationChangeTriggerUrl === event.url ? this.createIdleState() : this.ignore(event);
             };
             /**
              * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.onRouterEnd = /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.onRouterEnd = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
-                return this.ignore(event);
+                if (this.clickedLinkMatchedBackButtonUrl) {
+                    return this.finaliseRouting();
+                }
+                else {
+                    return this.ignore(event);
+                }
             };
             /**
              * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.onRouterError = /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.onRouterError = /**
              * @param {?} event
              * @return {?}
              */
@@ -4899,25 +5314,42 @@
              * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.onPopState = /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.onPopState = /**
              * @param {?} event
              * @return {?}
              */
             function (event) {
-                this.gotPopStateWithLeavingUrl = this.gotPopStateWithLeavingUrl || event.url === this.locationChangeTriggerUrl;
+                this.popStateEventUrl = event.url;
                 return this.ignore(event);
             };
-            // @Trace()
-            // @Trace()
+            /**
+             * @return {?}
+             */
+            LinkTriggeredNavigationInteractionCancelled.prototype.finaliseRouting = /**
+             * @return {?}
+             */
+            function () {
+                pectin.Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+                this.resetBrowserLocation(this.clickedLinkUrl); // put the back click one back in.
+                if (this.interactionService.isActive()) {
+                    /** @type {?} */
+                    var interactionIds = this.interactionService.activeInteractionContextIds.value;
+                    // Angular doesn't preserve the url when a guard cancels the back button.
+                    // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                    this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+                }
+                else {
+                    this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
+                }
+                return this.createIdleState();
+            };
             /**
              * @param {?} component
              * @param {?} currentUrl
              * @param {?} nextUrl
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.canDeactivatePlace = 
-            // @Trace()
-            /**
+            LinkTriggeredNavigationInteractionCancelled.prototype.canDeactivatePlace = /**
              * @param {?} component
              * @param {?} currentUrl
              * @param {?} nextUrl
@@ -4930,47 +5362,185 @@
                     });
                 });
             };
+            return LinkTriggeredNavigationInteractionCancelled;
+        }(NavigationState));
+        NavigationState.LinkTriggeredNavigationInteractionCancelled = LinkTriggeredNavigationInteractionCancelled;
+        if (false) {
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.isPopState;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.firstCancelEventUrl;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.popStateEventUrl;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.clickedLinkMatchedBackButtonUrl;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.debugPropertyKeys;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.startingUrl;
+            /** @type {?} */
+            LinkTriggeredNavigationInteractionCancelled.prototype.clickedLinkUrl;
+        }
+        /**
+         * This state handles the scenario where a pop state triggered and interaction and the user clickeb back a second time to cancel it.
+         * The sequence of routing events/state transitions is as follows.
+         * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )
+         * -> confirm dialog shown.
+         * -> click back
+         * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)
+         * -> NavigationCancel (for the previous back)
+         * -> PopState
+         * -> NavigationCancel
+         */
+        var /**
+         * This state handles the scenario where a pop state triggered and interaction and the user clickeb back a second time to cancel it.
+         * The sequence of routing events/state transitions is as follows.
+         * -> Idle -> PopStateTransition (poppedHistoryUrl == page to go to, startingUrl = page to stay on )
+         * -> confirm dialog shown.
+         * -> click back
+         * -> PopStateTransition -> CancelledDuringBackButtonNavigationInteraction(trigger url is the page before the popped history url)
+         * -> NavigationCancel (for the previous back)
+         * -> PopState
+         * -> NavigationCancel
+         */
+        PopStateTriggeredNavigationInteractionCancelled = /** @class */ (function (_super) {
+            __extends(PopStateTriggeredNavigationInteractionCancelled, _super);
+            function PopStateTriggeredNavigationInteractionCancelled(context, startingUrl, locationChangeTriggerUrl, poppedHistoryUrl) {
+                var _this = _super.call(this, context) || this;
+                _this.startingUrl = startingUrl;
+                _this.locationChangeTriggerUrl = locationChangeTriggerUrl;
+                _this.poppedHistoryUrl = poppedHistoryUrl;
+                _this.isPopState = false;
+                _this.firstCancelHandled = false;
+                _this.popStateHandled = false;
+                _this.debugPropertyKeys = ['idle', 'startingUrl', 'poppedHistoryUrl', 'locationChangeTriggerUrl', 'popStateEventUrl', 'firstCancelHandled', 'popStateHandled'];
+                return _this;
+            }
+            Object.defineProperty(PopStateTriggeredNavigationInteractionCancelled.prototype, "isTransitional", {
+                get: /**
+                 * @return {?}
+                 */
+                function () {
+                    return true;
+                },
+                enumerable: true,
+                configurable: true
+            });
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.onRouterStarted = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
+            };
             /**
              * @param {?} event
-             * @param {?=} reason
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.ignore = /**
+            PopStateTriggeredNavigationInteractionCancelled.prototype.onRouterCancelled = /**
              * @param {?} event
-             * @param {?=} reason
              * @return {?}
              */
-            function (event, reason) {
-                reason = reason ? " -> " + reason : '';
-                pectin.Logger.get(this).info("ignoring router event" + reason + ": " + event.constructor.name + " -> " + event.url);
-                return this;
+            function (event) {
+                if (this.firstCancelHandled && this.popStateHandled) {
+                    // Angular doesn't preserve the url when a guard cancels the back button.
+                    // See https://github.com/angular/angular/issues/13586#issuecomment-432795720
+                    pectin.Logger.get(this).info('WORK-AROUND: Updating browser location after pop state - see angular issue #13586');
+                    this.resetBrowserLocation(this.locationChangeTriggerUrl); // put the second back click one back in.
+                    this.resetBrowserLocation(this.poppedHistoryUrl); // put the first back click one back in.
+                    if (this.interactionService.isActive()) {
+                        /** @type {?} */
+                        var interactionIds = this.interactionService.activeInteractionContextIds.value;
+                        this.resetBrowserLocation(this.placeRouter.parseUrl(this.startingUrl).updateInteractionIds(interactionIds).url);
+                    }
+                    else {
+                        this.resetBrowserLocation(this.startingUrl); // and now put our own url back in.
+                    }
+                    return this.createIdleState();
+                }
+                else {
+                    this.firstCancelHandled = true;
+                    return this.ignore(event);
+                }
             };
             /**
+             * @param {?} event
              * @return {?}
              */
-            CancelledDuringNavigationInteraction.prototype.toString = /**
+            PopStateTriggeredNavigationInteractionCancelled.prototype.onRouterEnd = /**
+             * @param {?} event
              * @return {?}
              */
-            function () {
-                return this.constructor.name + "(isIdl: " + this.idle + ", startingUrl: " + this.startingUrl + ", locationChangeTriggerUrl:" + this.locationChangeTriggerUrl + ")";
+            function (event) {
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.onRouterError = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                return this.ignore(event);
             };
-            return CancelledDuringNavigationInteraction;
+            /**
+             * @param {?} event
+             * @return {?}
+             */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.onPopState = /**
+             * @param {?} event
+             * @return {?}
+             */
+            function (event) {
+                this.popStateHandled = true;
+                this.popStateEventUrl = event.url;
+                return this.ignore(event);
+            };
+            /**
+             * @param {?} component
+             * @param {?} currentUrl
+             * @param {?} nextUrl
+             * @return {?}
+             */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.canDeactivatePlace = /**
+             * @param {?} component
+             * @param {?} currentUrl
+             * @param {?} nextUrl
+             * @return {?}
+             */
+            function (component, currentUrl, nextUrl) {
+                return __awaiter(this, void 0, void 0, function () {
+                    return __generator(this, function (_a) {
+                        return [2 /*return*/, false];
+                    });
+                });
+            };
+            return PopStateTriggeredNavigationInteractionCancelled;
         }(NavigationState));
-        NavigationState.CancelledDuringNavigationInteraction = CancelledDuringNavigationInteraction;
+        NavigationState.PopStateTriggeredNavigationInteractionCancelled = PopStateTriggeredNavigationInteractionCancelled;
         if (false) {
             /** @type {?} */
-            CancelledDuringNavigationInteraction.prototype.isPopState;
-            /**
-             * @type {?}
-             * @private
-             */
-            CancelledDuringNavigationInteraction.prototype.gotPopStateWithLeavingUrl;
+            PopStateTriggeredNavigationInteractionCancelled.prototype.isPopState;
+            /** @type {?} */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.firstCancelHandled;
+            /** @type {?} */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.popStateHandled;
+            /** @type {?} */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.popStateEventUrl;
+            /** @type {?} */
+            PopStateTriggeredNavigationInteractionCancelled.prototype.debugPropertyKeys;
             /** @type {?} */
-            CancelledDuringNavigationInteraction.prototype.startingUrl;
+            PopStateTriggeredNavigationInteractionCancelled.prototype.startingUrl;
             /** @type {?} */
-            CancelledDuringNavigationInteraction.prototype.startingEventWasAPopState;
+            PopStateTriggeredNavigationInteractionCancelled.prototype.locationChangeTriggerUrl;
             /** @type {?} */
-            CancelledDuringNavigationInteraction.prototype.locationChangeTriggerUrl;
+            PopStateTriggeredNavigationInteractionCancelled.prototype.poppedHistoryUrl;
         }
     })(exports.NavigationState || (exports.NavigationState = {}));
 
@@ -8130,7 +8700,8 @@
             /** @type {?} */
             var param = new exports.ParameterDefinition.RouteId(propertyKey.toString(), options, type);
             typescriptUtilities.Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
-            pectin.UseDelegate({ tag: "@RouteId(" + prototype.constructor.name + "." + propertyKey.toString() + ")" })(prototype, propertyKey);
+            // UseDelegate({tag: `@RouteId(${prototype.constructor.name}.${propertyKey.toString()})`})(prototype, propertyKey);
+            pectin.UseDelegate()(prototype, propertyKey);
         });
     }
     /**
@@ -8150,7 +8721,8 @@
             /** @type {?} */
             var param = new exports.ParameterDefinition.ValueParameter(propertyKey.toString(), options, opts.getOptional("storeInUrl", null));
             typescriptUtilities.Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
-            pectin.UseDelegate({ tag: "@VisitParameter(" + prototype.constructor.name + "." + propertyKey.toString() + ")" })(prototype, propertyKey);
+            // UseDelegate({tag: `@VisitParameter(${prototype.constructor.name}.${propertyKey.toString()})`})(prototype, propertyKey);
+            pectin.UseDelegate()(prototype, propertyKey);
         });
     }
     /**
@@ -8170,7 +8742,8 @@
             /** @type {?} */
             var param = new exports.ParameterDefinition.ArrayParameter(propertyKey.toString(), options, opts.getOptional("storeInUrl", null));
             typescriptUtilities.Klass.get(prototype).addToOwnMetadataList(ROUTE_PARAMETER_LIST_KEY, param);
-            pectin.UseDelegate({ tag: "@VisitParameterList(" + prototype.constructor.name + "." + propertyKey.toString() + ")" })(prototype, propertyKey);
+            pectin.UseDelegate()(prototype, propertyKey);
+            // UseDelegate({tag: `@VisitParameterList(${prototype.constructor.name}.${propertyKey.toString()})`})(prototype, propertyKey);
         });
     }