@covalent/guided-tour 4.0.0-alpha.0 → 4.0.0-beta.1

package/fesm2015/{covalent-guided-tour.js → covalent-guided-tour.mjs}

@@ -1,139 +1,27 @@
+import * as i0 from '@angular/core';
 import { Injectable, NgModule } from '@angular/core';
 import { CommonModule } from '@angular/common';
 import { __awaiter } from 'tslib';
-import { HttpClient } from '@angular/common/http';
-import { NavigationStart, Router, ActivatedRoute } from '@angular/router';
+import * as i1 from '@angular/router';
+import { NavigationStart } from '@angular/router';
 import { first, takeUntil, skip, skipWhile, filter, debounceTime, tap, map } from 'rxjs/operators';
 import { Subject, merge, fromEvent, forkJoin, BehaviorSubject, timer } from 'rxjs';
 import Shepherd from 'shepherd.js';
+import * as i2 from '@angular/common/http';
 
-/**
- * @fileoverview added by tsickle
- * Generated from: guided.tour.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/** @enum {string} */
-const ITourEvent = {
-    'click': "click",
-    'pointerover': "pointerover",
-    'keyup': "keyup",
-    'added': "added",
-    'removed': "removed",
-};
-/**
- * @record
- */
-function ITourEventOn() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourEventOn.prototype.selector;
-    /** @type {?|undefined} */
-    ITourEventOn.prototype.event;
-}
-/**
- * @record
- */
-function ITourEventOnOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourEventOnOptions.prototype.timeBeforeShow;
-    /** @type {?|undefined} */
-    ITourEventOnOptions.prototype.interval;
-}
-/**
- * @record
- */
-function ITourAbortOn() { }
-/**
- * @record
- */
-function ITourOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourOptions.prototype.abortOn;
-}
-/**
- * @record
- */
-function ITourStepAttachToOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.highlight;
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.retries;
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.skipIfNotFound;
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.else;
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.goBackTo;
-    /** @type {?|undefined} */
-    ITourStepAttachToOptions.prototype.skipFromStepCount;
-}
-/**
- * @record
- */
-function ITourStepAdvanceOn() { }
-/**
- * @record
- */
-function ITourStepAdvanceOnOptions() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourStepAdvanceOnOptions.prototype.jumpTo;
-    /** @type {?|undefined} */
-    ITourStepAdvanceOnOptions.prototype.allowGoBack;
-}
-/**
- * @record
- */
-function ITourStep() { }
-if (false) {
-    /** @type {?|undefined} */
-    ITourStep.prototype.attachToOptions;
-    /** @type {?|undefined} */
-    ITourStep.prototype.advanceOnOptions;
-    /** @type {?|undefined} */
-    ITourStep.prototype.advanceOn;
-    /** @type {?|undefined} */
-    ITourStep.prototype.abortOn;
-    /** @type {?|undefined} */
-    ITourStep.prototype.count;
-}
-/**
- * @abstract
- */
+var ITourEvent;
+(function (ITourEvent) {
+    ITourEvent["click"] = "click";
+    ITourEvent["pointerover"] = "pointerover";
+    ITourEvent["keyup"] = "keyup";
+    ITourEvent["added"] = "added";
+    ITourEvent["removed"] = "removed";
+})(ITourEvent || (ITourEvent = {}));
 class TourButtonsActions {
 }
-if (false) {
-    /**
-     * @abstract
-     * @return {?}
-     */
-    TourButtonsActions.prototype.next = function () { };
-    /**
-     * @abstract
-     * @return {?}
-     */
-    TourButtonsActions.prototype.back = function () { };
-    /**
-     * @abstract
-     * @return {?}
-     */
-    TourButtonsActions.prototype.cancel = function () { };
-    /**
-     * @abstract
-     * @return {?}
-     */
-    TourButtonsActions.prototype.finish = function () { };
-}
-/** @type {?} */
 const SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW = 100;
-/** @type {?} */
 const SHEPHERD_DEFAULT_FIND_INTERVAL = 500;
-/** @type {?} */
 const SHEPHERD_DEFAULT_FIND_ATTEMPTS = 20;
-/** @type {?} */
 const overriddenEvents = [
     ITourEvent.click,
     ITourEvent.pointerover,
@@ -141,37 +29,25 @@ const overriddenEvents = [
     ITourEvent.added,
     ITourEvent.keyup,
 ];
-/** @type {?} */
 const keyEvents = new Map([
     [13, 'enter'],
     [27, 'esc'],
 ]);
-/** @type {?} */
 const defaultStepOptions = {
     scrollTo: { behavior: 'smooth', block: 'center' },
     cancelIcon: {
         enabled: true,
     },
 };
-/** @type {?} */
 const MAT_ICON_BUTTON = 'mat-icon-button material-icons mat-button-base';
-/** @type {?} */
 const MAT_BUTTON = 'mat-button-base mat-button';
-/** @type {?} */
 const MAT_BUTTON_INVISIBLE = 'shepherd-void-button';
 class CovalentGuidedTour extends TourButtonsActions {
-    /**
-     * @param {?=} stepOptions
-     */
     constructor(stepOptions = defaultStepOptions) {
         super();
         this.stepOptions = stepOptions;
         this.newTour();
     }
-    /**
-     * @param {?=} opts
-     * @return {?}
-     */
     newTour(opts) {
         this.shepherdTour = new Shepherd.Tour(Object.assign({
             defaultStepOptions: this.stepOptions,
@@ -180,133 +56,74 @@ class CovalentGuidedTour extends TourButtonsActions {
         // listen to cancel and complete to clean up abortOn events
         merge(fromEvent(this.shepherdTour, 'cancel'), fromEvent(this.shepherdTour, 'complete'))
             .pipe(first())
-            .subscribe((/**
-         * @return {?}
-         */
-        () => {
+            .subscribe(() => {
             this._destroyedEvent$.next();
             this._destroyedEvent$.complete();
-        }));
+        });
         // if abortOn was passed, we bind the event and execute complete
         if (opts && opts.abortOn) {
-            /** @type {?} */
             const abortArr$ = [];
-            opts.abortOn.forEach((/**
-             * @param {?} abortOn
-             * @return {?}
-             */
-            (abortOn) => {
-                /** @type {?} */
+            opts.abortOn.forEach((abortOn) => {
                 const abortEvent$ = new Subject();
                 abortArr$.push(abortEvent$);
                 this._bindEvent(abortOn, undefined, abortEvent$, this._destroyedEvent$);
-            }));
-            /** @type {?} */
+            });
             const abortSubs = merge(...abortArr$)
                 .pipe(takeUntil(this._destroyedEvent$))
-                .subscribe((/**
-             * @return {?}
-             */
-            () => {
+                .subscribe(() => {
                 this.shepherdTour.complete();
                 abortSubs.unsubscribe();
-            }));
+            });
         }
     }
-    /**
-     * @return {?}
-     */
     back() {
         this.shepherdTour.back();
     }
-    /**
-     * @return {?}
-     */
     cancel() {
         this.shepherdTour.cancel();
     }
-    /**
-     * @return {?}
-     */
     next() {
         this.shepherdTour.next();
     }
-    /**
-     * @return {?}
-     */
     finish() {
         this.shepherdTour.complete();
     }
-    /**
-     * @param {?} steps
-     * @return {?}
-     */
     addSteps(steps) {
         this.shepherdTour.addSteps(this._prepareTour(steps));
     }
-    /**
-     * @return {?}
-     */
     start() {
         this.shepherdTour.start();
     }
-    /**
-     * @protected
-     * @param {?} originalSteps
-     * @param {?=} finishLabel
-     * @return {?}
-     */
     _prepareTour(originalSteps, finishLabel = 'finish') {
         // create Subjects for back and forward events
-        /** @type {?} */
         const backEvent$ = new Subject();
-        /** @type {?} */
         const forwardEvent$ = new Subject();
-        /** @type {?} */
         let _backFlow = false;
         // create Subject for your end
-        /** @type {?} */
         const destroyedEvent$ = new Subject();
         /**
          * This function adds the step progress in the footer of the shepherd tooltip
-         * @type {?}
-         */
-        const appendProgressFunc = (/**
-         * @return {?}
          */
-        function () {
+        const appendProgressFunc = function () {
             // get all the footers that are available in the DOM
-            /** @type {?} */
             const footers = Array.from(document.querySelectorAll('.shepherd-footer'));
             // get the last footer since Shepherd always puts the active one at the end
-            /** @type {?} */
             const footer = footers[footers.length - 1];
             // generate steps html element
-            /** @type {?} */
             const progress = document.createElement('span');
             progress.className = 'shepherd-progress';
             progress.innerText = `${this.shepherdTour.currentStep.options.count}/${stepTotal}`;
             // insert into the footer before the first button
             footer.insertBefore(progress, footer.querySelector('.shepherd-button'));
-        });
-        /** @type {?} */
+        };
         let stepTotal = 0;
-        /** @type {?} */
-        const steps = originalSteps.map((/**
-         * @param {?} step
-         * @return {?}
-         */
-        (step) => {
+        const steps = originalSteps.map((step) => {
             var _a, _b, _c;
-            /** @type {?} */
             let showProgress;
             if (((_a = step.attachToOptions) === null || _a === void 0 ? void 0 : _a.skipFromStepCount) === true) {
-                showProgress = (/**
-                 * @return {?}
-                 */
-                function () {
+                showProgress = function () {
                     return;
-                });
+                };
             }
             else if (((_b = step.attachToOptions) === null || _b === void 0 ? void 0 : _b.skipFromStepCount) === undefined ||
                 ((_c = step.attachToOptions) === null || _c === void 0 ? void 0 : _c.skipFromStepCount) === false) {
@@ -318,65 +135,43 @@ class CovalentGuidedTour extends TourButtonsActions {
                     show: showProgress,
                 },
             });
-        }));
-        /** @type {?} */
+        });
         const finishButton = {
             text: finishLabel,
             action: this['finish'].bind(this),
             classes: MAT_BUTTON,
         };
-        /** @type {?} */
         const voidButton = {
             text: '',
-            /**
-             * @return {?}
-             */
             action() {
                 return;
             },
             classes: MAT_BUTTON_INVISIBLE,
         };
         // listen to the destroyed event to clean up all the streams
-        this._destroyedEvent$.pipe(first()).subscribe((/**
-         * @return {?}
-         */
-        () => {
+        this._destroyedEvent$.pipe(first()).subscribe(() => {
             backEvent$.complete();
             forwardEvent$.complete();
             destroyedEvent$.next();
             destroyedEvent$.complete();
-        }));
-        /** @type {?} */
+        });
         const totalSteps = steps.length;
-        steps.forEach((/**
-         * @param {?} step
-         * @param {?} index
-         * @return {?}
-         */
-        (step, index) => {
+        steps.forEach((step, index) => {
             var _a;
             // create buttons specific for the step
             // this is done to create more control on events
-            /** @type {?} */
             const nextButton = {
                 text: 'chevron_right',
-                action: (/**
-                 * @return {?}
-                 */
-                () => {
+                action: () => {
                     // intercept the next action and trigger event
                     forwardEvent$.next();
                     this.shepherdTour.next();
-                }),
+                },
                 classes: MAT_ICON_BUTTON,
             };
-            /** @type {?} */
             const backButton = {
                 text: 'chevron_left',
-                action: (/**
-                 * @return {?}
-                 */
-                () => {
+                action: () => {
                     // intercept the back action and trigger event
                     backEvent$.next();
                     _backFlow = true;
@@ -387,7 +182,7 @@ class CovalentGuidedTour extends TourButtonsActions {
                     else {
                         this.shepherdTour.back();
                     }
-                }),
+                },
                 classes: ((_a = step.advanceOnOptions) === null || _a === void 0 ? void 0 : _a.allowGoBack) === false ? MAT_BUTTON_INVISIBLE : MAT_ICON_BUTTON,
             };
             // check if highlight was provided for the step, else fallback into shepherds usage
@@ -408,7 +203,6 @@ class CovalentGuidedTour extends TourButtonsActions {
                 }
             }
             // checks "advanceOn" to override listeners
-            /** @type {?} */
             let advanceOn = step.advanceOn;
             // remove the shepherd "advanceOn" infavor of ours if the event is part of our list
             if ((typeof advanceOn === 'object' &&
@@ -420,45 +214,23 @@ class CovalentGuidedTour extends TourButtonsActions {
                     step.advanceOnOptions && step.advanceOnOptions.allowGoBack ? [backButton, voidButton] : [voidButton];
             }
             // adds a default beforeShowPromise function
-            step.beforeShowPromise = (/**
-             * @return {?}
-             */
-            () => {
-                return new Promise((/**
-                 * @param {?} resolve
-                 * @return {?}
-                 */
-                (resolve) => {
-                    /** @type {?} */
-                    const additionalCapabilitiesSetup = (/**
-                     * @return {?}
-                     */
-                    () => {
+            step.beforeShowPromise = () => {
+                return new Promise((resolve) => {
+                    const additionalCapabilitiesSetup = () => {
                         if (advanceOn && !step.advanceOn) {
                             if (!Array.isArray(advanceOn)) {
                                 advanceOn = [advanceOn];
                             }
-                            /** @type {?} */
                             const advanceArr$ = [];
-                            advanceOn.forEach((/**
-                             * @param {?} _
-                             * @param {?} i
-                             * @return {?}
-                             */
-                            (_, i) => {
-                                /** @type {?} */
+                            advanceOn.forEach((_, i) => {
                                 const advanceEvent$ = new Subject();
                                 advanceArr$.push(advanceEvent$);
                                 // we start a timer of attempts to find an element in the dom
                                 this._bindEvent(advanceOn[i], step.advanceOnOptions, advanceEvent$, destroyedEvent$);
-                            }));
-                            /** @type {?} */
+                            });
                             const advanceSubs = forkJoin(...advanceArr$)
                                 .pipe(takeUntil(merge(destroyedEvent$, backEvent$)))
-                                .subscribe((/**
-                             * @return {?}
-                             */
-                            () => {
+                                .subscribe(() => {
                                 // check if we need to advance to a specific step, else advance to next step
                                 if (step.advanceOnOptions && step.advanceOnOptions.jumpTo) {
                                     this.shepherdTour.show(step.advanceOnOptions.jumpTo);
@@ -468,41 +240,27 @@ class CovalentGuidedTour extends TourButtonsActions {
                                 }
                                 forwardEvent$.next();
                                 advanceSubs.unsubscribe();
-                            }));
+                            });
                         }
                         // if abortOn was passed on the step, we bind the event and execute complete
                         if (step.abortOn) {
-                            /** @type {?} */
                             const abortArr$ = [];
-                            step.abortOn.forEach((/**
-                             * @param {?} abortOn
-                             * @return {?}
-                             */
-                            (abortOn) => {
-                                /** @type {?} */
+                            step.abortOn.forEach((abortOn) => {
                                 const abortEvent$ = new Subject();
                                 abortArr$.push(abortEvent$);
                                 this._bindEvent(abortOn, undefined, abortEvent$, destroyedEvent$);
-                            }));
-                            /** @type {?} */
+                            });
                             const abortSubs = merge(...abortArr$)
                                 .pipe(takeUntil(merge(destroyedEvent$, backEvent$, forwardEvent$)))
-                                .subscribe((/**
-                             * @return {?}
-                             */
-                            () => {
+                                .subscribe(() => {
                                 this.shepherdTour.complete();
                                 abortSubs.unsubscribe();
-                            }));
+                            });
                         }
-                    });
-                    /** @type {?} */
+                    };
                     const _stopTimer$ = new Subject();
-                    /** @type {?} */
                     const _retriesReached$ = new Subject();
-                    /** @type {?} */
                     const _retryAttempts$ = new BehaviorSubject(-1);
-                    /** @type {?} */
                     let id;
                     // checks if "attachTo" is a string or an object to get the id of an element
                     if (typeof step.attachTo === 'string') {
@@ -515,28 +273,20 @@ class CovalentGuidedTour extends TourButtonsActions {
                     if (id) {
                         // if current step is the first step of the tour, we set the buttons to be only "next"
                         // we had to use `any` since the tour doesnt expose the steps in any fashion nor a way to check if we have modified them at all
-                        if (this.shepherdTour.getCurrentStep() === ((/** @type {?} */ (this.shepherdTour))).steps[0]) {
+                        if (this.shepherdTour.getCurrentStep() === this.shepherdTour.steps[0]) {
                             this.shepherdTour.getCurrentStep().updateStepOptions({
                                 buttons: originalSteps[index].advanceOn ? [voidButton] : [nextButton],
                             });
                         }
                         // register to the attempts observable to notify deeveloper when number has been reached
                         _retryAttempts$
-                            .pipe(skip(1), takeUntil(merge(_stopTimer$.asObservable(), destroyedEvent$)), skipWhile((/**
-                         * @param {?} val
-                         * @return {?}
-                         */
-                        (val) => {
+                            .pipe(skip(1), takeUntil(merge(_stopTimer$.asObservable(), destroyedEvent$)), skipWhile((val) => {
                             if (step.attachToOptions && step.attachToOptions.retries !== undefined) {
                                 return val < step.attachToOptions.retries;
                             }
                             return val < SHEPHERD_DEFAULT_FIND_ATTEMPTS;
-                        })))
-                            .subscribe((/**
-                         * @param {?} attempts
-                         * @return {?}
-                         */
-                        (attempts) => {
+                        }))
+                            .subscribe((attempts) => {
                             _retriesReached$.next();
                             _retriesReached$.complete();
                             // if attempts have been reached, we check "skipIfNotFound" to move on to the next step
@@ -545,7 +295,7 @@ class CovalentGuidedTour extends TourButtonsActions {
                                 // then we either check if its the first step and try going forward
                                 // or we keep going back until we find a step that actually exists
                                 if (_backFlow) {
-                                    if (((/** @type {?} */ (this.shepherdTour))).steps.indexOf(this.shepherdTour.getCurrentStep()) === 0) {
+                                    if (this.shepherdTour.steps.indexOf(this.shepherdTour.getCurrentStep()) === 0) {
                                         this.shepherdTour.next();
                                     }
                                     else {
@@ -555,11 +305,10 @@ class CovalentGuidedTour extends TourButtonsActions {
                                 }
                                 else {
                                     // destroys current step if we need to skip it to remove it from the tour
-                                    /** @type {?} */
                                     const currentStep = this.shepherdTour.getCurrentStep();
                                     currentStep.destroy();
                                     this.shepherdTour.next();
-                                    this.shepherdTour.removeStep(((/** @type {?} */ (currentStep))).id);
+                                    this.shepherdTour.removeStep(currentStep.id);
                                 }
                             }
                             else if (step.attachToOptions && step.attachToOptions.else) {
@@ -572,17 +321,13 @@ class CovalentGuidedTour extends TourButtonsActions {
                                 // else we show the step regardless
                                 resolve();
                             }
-                        }));
+                        });
                         // we start a timer of attempts to find an element in the dom
                         timer((step.attachToOptions && step.attachToOptions.timeBeforeShow) || SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW, (step.attachToOptions && step.attachToOptions.interval) || SHEPHERD_DEFAULT_FIND_INTERVAL)
                             .pipe(
                         // the timer will continue either until we find the element or the number of attempts has been reached
                         takeUntil(merge(_stopTimer$, _retriesReached$, destroyedEvent$)))
-                            .subscribe((/**
-                         * @return {?}
-                         */
-                        () => {
-                            /** @type {?} */
+                            .subscribe(() => {
                             const element = document.querySelector(id);
                             // if the element has been found, we stop the timer and resolve the promise
                             if (element) {
@@ -594,56 +339,35 @@ class CovalentGuidedTour extends TourButtonsActions {
                             else {
                                 _retryAttempts$.next(_retryAttempts$.value + 1);
                             }
-                        }));
+                        });
                         // stop find interval if user stops the tour
-                        destroyedEvent$.subscribe((/**
-                         * @return {?}
-                         */
-                        () => {
+                        destroyedEvent$.subscribe(() => {
                             _stopTimer$.next();
                             _stopTimer$.complete();
                             _retriesReached$.next();
                             _retriesReached$.complete();
-                        }));
+                        });
                     }
                     else {
                         // resolve observable until the timeBeforeShow has passsed or use default
                         timer((step.attachToOptions && step.attachToOptions.timeBeforeShow) || SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW)
                             .pipe(takeUntil(merge(destroyedEvent$)))
-                            .subscribe((/**
-                         * @return {?}
-                         */
-                        () => {
+                            .subscribe(() => {
                             resolve();
-                        }));
+                        });
                     }
-                }));
-            });
-        }));
+                });
+            };
+        });
         return steps;
     }
-    /**
-     * @private
-     * @param {?} eventOn
-     * @param {?} eventOnOptions
-     * @param {?} event$
-     * @param {?} destroyedEvent$
-     * @return {?}
-     */
     _bindEvent(eventOn, eventOnOptions, event$, destroyedEvent$) {
-        /** @type {?} */
         const selector = eventOn.selector;
-        /** @type {?} */
         const event = eventOn.event;
         // we start a timer of attempts to find an element in the dom
-        /** @type {?} */
         const timerSubs = timer((eventOnOptions && eventOnOptions.timeBeforeShow) || SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW, (eventOnOptions && eventOnOptions.interval) || SHEPHERD_DEFAULT_FIND_INTERVAL)
             .pipe(takeUntil(destroyedEvent$))
-            .subscribe((/**
-         * @return {?}
-         */
-        () => {
-            /** @type {?} */
+            .subscribe(() => {
             const element = document.querySelector(selector);
             // if the element has been found, we stop the timer and resolve the promise
             if (element) {
@@ -657,16 +381,10 @@ class CovalentGuidedTour extends TourButtonsActions {
                     event === ITourEvent.pointerover ||
                     event.indexOf(ITourEvent.keyup) > -1) {
                     // we use normal listeners for mouseevents
-                    /** @type {?} */
                     const mainEvent = event.split('.')[0];
-                    /** @type {?} */
                     const subEvent = event.split('.')[1];
                     fromEvent(element, mainEvent)
-                        .pipe(takeUntil(merge(event$.asObservable(), destroyedEvent$)), filter((/**
-                     * @param {?} $event
-                     * @return {?}
-                     */
-                    ($event) => {
+                        .pipe(takeUntil(merge(event$.asObservable(), destroyedEvent$)), filter(($event) => {
                         // only trigger if the event is a keyboard event and part of out list
                         if ($event instanceof KeyboardEvent) {
                             if (keyEvents.get($event.keyCode) === subEvent) {
@@ -677,105 +395,47 @@ class CovalentGuidedTour extends TourButtonsActions {
                         else {
                             return true;
                         }
-                    })))
-                        .subscribe((/**
-                     * @return {?}
-                     */
-                    () => {
+                    }))
+                        .subscribe(() => {
                         event$.next();
                         event$.complete();
-                    }));
+                    });
                 }
                 else if (event === ITourEvent.removed) {
                     // and we will use MutationObserver for DOM events
-                    /** @type {?} */
-                    const observer = new MutationObserver((/**
-                     * @return {?}
-                     */
-                    () => {
+                    const observer = new MutationObserver(() => {
                         if (!document.body.contains(element)) {
                             event$.next();
                             event$.complete();
                             observer.disconnect();
                         }
-                    }));
+                    });
                     // stop listenining if tour is closed
-                    destroyedEvent$.subscribe((/**
-                     * @return {?}
-                     */
-                    () => {
+                    destroyedEvent$.subscribe(() => {
                         observer.disconnect();
-                    }));
+                    });
                     // observe for any DOM interaction in the element
                     observer.observe(element, { childList: true, subtree: true, attributes: true });
                 }
             }
-        }));
+        });
     }
 }
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTour.prototype._destroyedEvent$;
-    /** @type {?} */
-    CovalentGuidedTour.prototype.shepherdTour;
-    /** @type {?} */
-    CovalentGuidedTour.prototype.stepOptions;
-}
 
 /**
- * @fileoverview added by tsickle
- * Generated from: guided-tour.service.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-/**
- * @record
- */
-function IGuidedTour() { }
-if (false) {
-    /** @type {?} */
-    IGuidedTour.prototype.steps;
-    /** @type {?|undefined} */
-    IGuidedTour.prototype.finishButtonText;
-}
-/**
- * @record
- */
-function IGuidedTourStep() { }
-if (false) {
-    /** @type {?|undefined} */
-    IGuidedTourStep.prototype.routing;
-}
-/** @enum {string} */
-const TourEvents = {
-    complete: "complete",
-    cancel: "cancel",
-    hide: "hide",
-    show: "show",
-    start: "start",
-    active: "active",
-    inactive: "inactive",
-};
-/**
- * @record
+ *  Router enabled Shepherd tour
  */
-function IGuidedTourEvent() { }
-if (false) {
-    /** @type {?} */
-    IGuidedTourEvent.prototype.step;
-    /** @type {?} */
-    IGuidedTourEvent.prototype.previous;
-    /** @type {?} */
-    IGuidedTourEvent.prototype.tour;
-}
+var TourEvents;
+(function (TourEvents) {
+    TourEvents["complete"] = "complete";
+    TourEvents["cancel"] = "cancel";
+    TourEvents["hide"] = "hide";
+    TourEvents["show"] = "show";
+    TourEvents["start"] = "start";
+    TourEvents["active"] = "active";
+    TourEvents["inactive"] = "inactive";
+})(TourEvents || (TourEvents = {}));
 class CovalentGuidedTourService extends CovalentGuidedTour {
-    /**
-     * @param {?} _router
-     * @param {?} _route
-     * @param {?} _httpClient
-     */
     constructor(_router, _route, _httpClient) {
         super();
         this._router = _router;
@@ -784,64 +444,34 @@ class CovalentGuidedTourService extends CovalentGuidedTour {
         this._toursMap = new Map();
         this._tourStepURLs = new Map();
         _router.events
-            .pipe(filter((/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => event instanceof NavigationStart && event.navigationTrigger === 'popstate')))
-            .subscribe((/**
-         * @param {?} event
-         * @return {?}
-         */
-        (event) => {
+            .pipe(filter((event) => event instanceof NavigationStart && event.navigationTrigger === 'popstate'))
+            .subscribe((event) => {
             if (this.shepherdTour.isActive) {
                 this.shepherdTour.cancel();
             }
-        }));
+        });
     }
-    /**
-     * @param {?} str
-     * @return {?}
-     */
     tourEvent$(str) {
         return fromEvent(this.shepherdTour, str);
     }
-    /**
-     * @param {?} tourName
-     * @param {?} tour
-     * @return {?}
-     */
     registerTour(tourName, tour) {
         return __awaiter(this, void 0, void 0, function* () {
-            /** @type {?} */
             const guidedTour = typeof tour === 'string' ? yield this._loadTour(tour) : tour;
             this._toursMap.set(tourName, guidedTour);
         });
     }
-    /**
-     * @param {?} tourName
-     * @return {?}
-     */
     startTour(tourName) {
-        /** @type {?} */
         const guidedTour = this._getTour(tourName);
         this.finish();
         if (guidedTour && guidedTour.steps && guidedTour.steps.length) {
             // remove steps from tour since we need to preprocess them first
             this.newTour(Object.assign({}, guidedTour, { steps: undefined }));
-            /** @type {?} */
             const tourInstance = this.shepherdTour.addSteps(this._configureRoutesForSteps(this._prepareTour(guidedTour.steps, guidedTour.finishButtonText)));
             // init route transition if step URL is different then the current location.
-            this.tourEvent$(TourEvents.show).subscribe((/**
-             * @param {?} tourEvent
-             * @return {?}
-             */
-            (tourEvent) => {
-                /** @type {?} */
+            this.tourEvent$(TourEvents.show).subscribe((tourEvent) => {
                 const currentURL = this._router.url.split(/[?#]/)[0];
                 const { step: { id, options }, } = tourEvent;
                 if (this._tourStepURLs.has(id)) {
-                    /** @type {?} */
                     const stepRoute = this._tourStepURLs.get(id);
                     if (stepRoute !== currentURL) {
                         this._router.navigate([stepRoute]);
@@ -855,7 +485,7 @@ class CovalentGuidedTourService extends CovalentGuidedTour {
                         this._tourStepURLs.set(id, currentURL);
                     }
                 }
-            }));
+            });
             this.start();
             return tourInstance;
         }
@@ -866,27 +496,16 @@ class CovalentGuidedTourService extends CovalentGuidedTour {
     }
     // Finds the right registered tour by using queryParams
     // finishes any other tour and starts the new one.
-    /**
-     * @param {?=} queryParam
-     * @return {?}
-     */
     initializeOnQueryParams(queryParam = 'tour') {
-        return this._route.queryParamMap.pipe(debounceTime(100), tap((/**
-         * @param {?} params
-         * @return {?}
-         */
-        (params) => {
-            /** @type {?} */
+        return this._route.queryParamMap.pipe(debounceTime(100), tap((params) => {
             const tourParam = params.get(queryParam);
             if (tourParam) {
                 this.startTour(tourParam);
                 // get current search parameters
-                /** @type {?} */
                 const searchParams = new URLSearchParams(window.location.search);
                 // delete tour queryParam
                 searchParams.delete(queryParam);
                 // build new URL string without it
-                /** @type {?} */
                 let url = window.location.protocol + '//' + window.location.host + window.location.pathname;
                 if (searchParams.toString()) {
                     url += '?' + searchParams.toString();
@@ -894,47 +513,27 @@ class CovalentGuidedTourService extends CovalentGuidedTour {
                 // replace state in history without triggering a navigation
                 window.history.replaceState({ path: url }, '', url);
             }
-        })));
+        }));
     }
-    /**
-     * @param {?} stepId
-     * @param {?} isDisabled
-     * @return {?}
-     */
     setNextBtnDisability(stepId, isDisabled) {
         if (this.shepherdTour.getById(stepId)) {
-            /** @type {?} */
-            const stepOptions = ((/** @type {?} */ (this.shepherdTour.getById(stepId)))).options;
-            stepOptions.buttons.forEach((/**
-             * @param {?} button
-             * @return {?}
-             */
-            (button) => {
+            const stepOptions = this.shepherdTour.getById(stepId).options;
+            stepOptions.buttons.forEach((button) => {
                 if (button.text === 'chevron_right') {
                     button.disabled = isDisabled;
                 }
-            }));
+            });
             this.shepherdTour.getById(stepId).updateStepOptions(stepOptions);
         }
     }
-    /**
-     * @private
-     * @param {?} tourUrl
-     * @return {?}
-     */
     _loadTour(tourUrl) {
         return __awaiter(this, void 0, void 0, function* () {
-            /** @type {?} */
             const request = this._httpClient.get(tourUrl);
             try {
                 return yield request
-                    .pipe(map((/**
-                 * @param {?} resultSet
-                 * @return {?}
-                 */
-                (resultSet) => {
+                    .pipe(map((resultSet) => {
                     return JSON.parse(JSON.stringify(resultSet));
-                })))
+                }))
                     .toPromise();
             }
             catch (_a) {
@@ -942,125 +541,59 @@ class CovalentGuidedTourService extends CovalentGuidedTour {
             }
         });
     }
-    /**
-     * @private
-     * @param {?} key
-     * @return {?}
-     */
     _getTour(key) {
         return this._toursMap.get(key);
     }
-    /**
-     * @private
-     * @param {?} routedSteps
-     * @return {?}
-     */
     _configureRoutesForSteps(routedSteps) {
-        routedSteps.forEach((/**
-         * @param {?} step
-         * @return {?}
-         */
-        (step) => {
+        routedSteps.forEach((step) => {
             if (step.routing) {
-                /** @type {?} */
                 const route = step.routing.route;
                 // if there is a beforeShowPromise, then we save it and call it after the navigation
                 if (step.beforeShowPromise) {
-                    /** @type {?} */
                     const beforeShowPromise = step.beforeShowPromise;
-                    step.beforeShowPromise = (/**
-                     * @return {?}
-                     */
-                    () => {
-                        return this._router.navigate([route], step.routing.extras).then((/**
-                         * @return {?}
-                         */
-                        () => {
+                    step.beforeShowPromise = () => {
+                        return this._router.navigate([route], step.routing.extras).then(() => {
                             return beforeShowPromise();
-                        }));
-                    });
+                        });
+                    };
                 }
                 else {
-                    step.beforeShowPromise = (/**
-                     * @return {?}
-                     */
-                    () => this._router.navigate([route]));
+                    step.beforeShowPromise = () => this._router.navigate([route]);
                 }
             }
-        }));
+        });
         return routedSteps;
     }
 }
-CovalentGuidedTourService.decorators = [
-    { type: Injectable }
-];
-/** @nocollapse */
-CovalentGuidedTourService.ctorParameters = () => [
-    { type: Router },
-    { type: ActivatedRoute },
-    { type: HttpClient }
-];
-if (false) {
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTourService.prototype._toursMap;
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTourService.prototype._tourStepURLs;
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTourService.prototype._router;
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTourService.prototype._route;
-    /**
-     * @type {?}
-     * @private
-     */
-    CovalentGuidedTourService.prototype._httpClient;
-}
+/** @nocollapse */ /** @nocollapse */ CovalentGuidedTourService.ɵfac = function CovalentGuidedTourService_Factory(t) { return new (t || CovalentGuidedTourService)(i0.ɵɵinject(i1.Router), i0.ɵɵinject(i1.ActivatedRoute), i0.ɵɵinject(i2.HttpClient)); };
+/** @nocollapse */ /** @nocollapse */ CovalentGuidedTourService.ɵprov = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjectable({ token: CovalentGuidedTourService, factory: CovalentGuidedTourService.ɵfac });
+(function () {
+    (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentGuidedTourService, [{
+            type: Injectable
+        }], function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.HttpClient }]; }, null);
+})();
 
-/**
- * @fileoverview added by tsickle
- * Generated from: guided-tour.module.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
 class CovalentGuidedTourModule {
 }
-CovalentGuidedTourModule.decorators = [
-    { type: NgModule, args: [{
-                imports: [CommonModule],
-                providers: [CovalentGuidedTourService],
-                declarations: [],
-                exports: [],
-            },] }
-];
-
-/**
- * @fileoverview added by tsickle
- * Generated from: public-api.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
-
-/**
- * @fileoverview added by tsickle
- * Generated from: index.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
- */
+/** @nocollapse */ /** @nocollapse */ CovalentGuidedTourModule.ɵfac = function CovalentGuidedTourModule_Factory(t) { return new (t || CovalentGuidedTourModule)(); };
+/** @nocollapse */ /** @nocollapse */ CovalentGuidedTourModule.ɵmod = /** @pureOrBreakMyCode */ i0.ɵɵdefineNgModule({ type: CovalentGuidedTourModule });
+/** @nocollapse */ /** @nocollapse */ CovalentGuidedTourModule.ɵinj = /** @pureOrBreakMyCode */ i0.ɵɵdefineInjector({ providers: [CovalentGuidedTourService], imports: [[CommonModule]] });
+(function () {
+    (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CovalentGuidedTourModule, [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    providers: [CovalentGuidedTourService],
+                    declarations: [],
+                    exports: [],
+                }]
+        }], null, null);
+})();
+(function () { (typeof ngJitMode === "undefined" || ngJitMode) && i0.ɵɵsetNgModuleScope(CovalentGuidedTourModule, { imports: [CommonModule] }); })();
 
 /**
- * @fileoverview added by tsickle
- * Generated from: covalent-guided-tour.ts
- * @suppress {checkTypes,constantProperty,extraRequire,missingOverride,missingRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
+ * Generated bundle index. Do not edit.
  */
 
 export { CovalentGuidedTour, CovalentGuidedTourModule, CovalentGuidedTourService, ITourEvent, TourEvents };
-//# sourceMappingURL=covalent-guided-tour.js.map
+//# sourceMappingURL=covalent-guided-tour.mjs.map