@covalent/guided-tour 4.0.0-beta.2 → 4.1.0-develop.10

package/esm2020/lib/guided.tour.mjs

@@ -0,0 +1,438 @@
+import Shepherd from 'shepherd.js';
+import { timer, Subject, BehaviorSubject, merge, fromEvent, forkJoin, } from 'rxjs';
+import { takeUntil, skipWhile, filter, skip, first } from 'rxjs/operators';
+export var ITourEvent;
+(function (ITourEvent) {
+    ITourEvent["click"] = "click";
+    ITourEvent["pointerover"] = "pointerover";
+    ITourEvent["keyup"] = "keyup";
+    ITourEvent["added"] = "added";
+    ITourEvent["removed"] = "removed";
+})(ITourEvent || (ITourEvent = {}));
+class TourButtonsActions {
+}
+const SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW = 100;
+const SHEPHERD_DEFAULT_FIND_INTERVAL = 500;
+const SHEPHERD_DEFAULT_FIND_ATTEMPTS = 20;
+const overriddenEvents = [
+    ITourEvent.click,
+    ITourEvent.pointerover,
+    ITourEvent.removed,
+    ITourEvent.added,
+    ITourEvent.keyup,
+];
+const keyEvents = new Map([
+    [13, 'enter'],
+    [27, 'esc'],
+]);
+const defaultStepOptions = {
+    scrollTo: { behavior: 'smooth', block: 'center' },
+    cancelIcon: {
+        enabled: true,
+    },
+};
+const MAT_ICON_BUTTON = 'mat-icon-button material-icons mat-button-base';
+const MAT_BUTTON = 'mat-button-base mat-button';
+const MAT_BUTTON_INVISIBLE = 'shepherd-void-button';
+export class CovalentGuidedTour extends TourButtonsActions {
+    constructor(stepOptions = defaultStepOptions) {
+        super();
+        this.stepOptions = stepOptions;
+        this.newTour();
+    }
+    newTour(opts) {
+        this.shepherdTour = new Shepherd.Tour(Object.assign({
+            defaultStepOptions: this.stepOptions,
+        }, opts));
+        this._destroyedEvent$ = new Subject();
+        // listen to cancel and complete to clean up abortOn events
+        merge(fromEvent(this.shepherdTour, 'cancel'), fromEvent(this.shepherdTour, 'complete'))
+            .pipe(first())
+            .subscribe(() => {
+            this._destroyedEvent$.next();
+            this._destroyedEvent$.complete();
+        });
+        // if abortOn was passed, we bind the event and execute complete
+        if (opts && opts.abortOn) {
+            const abortArr$ = [];
+            opts.abortOn.forEach((abortOn) => {
+                const abortEvent$ = new Subject();
+                abortArr$.push(abortEvent$);
+                this._bindEvent(abortOn, undefined, abortEvent$, this._destroyedEvent$);
+            });
+            const abortSubs = merge(...abortArr$)
+                .pipe(takeUntil(this._destroyedEvent$))
+                .subscribe(() => {
+                this.shepherdTour.complete();
+                abortSubs.unsubscribe();
+            });
+        }
+    }
+    back() {
+        this.shepherdTour.back();
+    }
+    cancel() {
+        this.shepherdTour.cancel();
+    }
+    next() {
+        this.shepherdTour.next();
+    }
+    finish() {
+        this.shepherdTour.complete();
+    }
+    addSteps(steps) {
+        this.shepherdTour.addSteps(this._prepareTour(steps));
+    }
+    start() {
+        this.shepherdTour.start();
+    }
+    _prepareTour(originalSteps, finishLabel = 'finish') {
+        // create Subjects for back and forward events
+        const backEvent$ = new Subject();
+        const forwardEvent$ = new Subject();
+        let _backFlow = false;
+        // create Subject for your end
+        const destroyedEvent$ = new Subject();
+        /**
+         * This function adds the step progress in the footer of the shepherd tooltip
+         */
+        const appendProgressFunc = function () {
+            // get all the footers that are available in the DOM
+            const footers = Array.from(document.querySelectorAll('.shepherd-footer'));
+            // get the last footer since Shepherd always puts the active one at the end
+            const footer = footers[footers.length - 1];
+            // generate steps html element
+            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'));
+        };
+        let stepTotal = 0;
+        const steps = originalSteps.map((step) => {
+            let showProgress = () => {
+                //
+            };
+            if (step.attachToOptions?.skipFromStepCount === true) {
+                showProgress = function () {
+                    return;
+                };
+            }
+            else if (step.attachToOptions?.skipFromStepCount === undefined ||
+                step.attachToOptions?.skipFromStepCount === false) {
+                step.count = ++stepTotal;
+                showProgress = appendProgressFunc.bind(this);
+            }
+            return Object.assign({}, step, {
+                when: {
+                    show: showProgress,
+                },
+            });
+        });
+        const finishButton = {
+            text: finishLabel,
+            action: this['finish'].bind(this),
+            classes: MAT_BUTTON,
+        };
+        const voidButton = {
+            text: '',
+            action() {
+                return;
+            },
+            classes: MAT_BUTTON_INVISIBLE,
+        };
+        // listen to the destroyed event to clean up all the streams
+        this._destroyedEvent$.pipe(first()).subscribe(() => {
+            backEvent$.complete();
+            forwardEvent$.complete();
+            destroyedEvent$.next();
+            destroyedEvent$.complete();
+        });
+        const totalSteps = steps.length;
+        steps.forEach((step, index) => {
+            // create buttons specific for the step
+            // this is done to create more control on events
+            const nextButton = {
+                text: 'chevron_right',
+                action: () => {
+                    // intercept the next action and trigger event
+                    forwardEvent$.next();
+                    this.shepherdTour.next();
+                },
+                classes: MAT_ICON_BUTTON,
+            };
+            const backButton = {
+                text: 'chevron_left',
+                action: () => {
+                    // intercept the back action and trigger event
+                    backEvent$.next();
+                    _backFlow = true;
+                    // check if 'goBackTo' is set to jump to a particular step, else just go back
+                    if (step.attachToOptions && step.attachToOptions.goBackTo) {
+                        this.shepherdTour.show(step.attachToOptions.goBackTo, false);
+                    }
+                    else {
+                        this.shepherdTour.back();
+                    }
+                },
+                classes: step.advanceOnOptions?.allowGoBack === false
+                    ? MAT_BUTTON_INVISIBLE
+                    : MAT_ICON_BUTTON,
+            };
+            // check if highlight was provided for the step, else fallback into shepherds usage
+            step.highlightClass =
+                step.attachToOptions && step.attachToOptions.highlight
+                    ? 'shepherd-highlight'
+                    : step.highlightClass;
+            // Adding buttons in the steps if no buttons are defined
+            if (!step.buttons || step.buttons.length === 0) {
+                if (index === 0) {
+                    // first step
+                    step.buttons = [nextButton];
+                }
+                else if (index === totalSteps - 1) {
+                    // last step
+                    step.buttons = [backButton, finishButton];
+                }
+                else {
+                    step.buttons = [backButton, nextButton];
+                }
+            }
+            // checks "advanceOn" to override listeners
+            let advanceOn = step.advanceOn;
+            // remove the shepherd "advanceOn" infavor of ours if the event is part of our list
+            if ((typeof advanceOn === 'object' &&
+                !Array.isArray(advanceOn) &&
+                advanceOn.event &&
+                overriddenEvents.indexOf(advanceOn.event.split('.')[0]) > -1) ||
+                advanceOn instanceof Array) {
+                step.advanceOn = undefined;
+                step.buttons =
+                    step.advanceOnOptions && step.advanceOnOptions.allowGoBack
+                        ? [backButton, voidButton]
+                        : [voidButton];
+            }
+            // adds a default beforeShowPromise function
+            step.beforeShowPromise = () => {
+                return new Promise((resolve) => {
+                    const additionalCapabilitiesSetup = () => {
+                        if (advanceOn && !step.advanceOn) {
+                            if (!Array.isArray(advanceOn)) {
+                                advanceOn = [advanceOn];
+                            }
+                            const advanceArr$ = [];
+                            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(_, step.advanceOnOptions, advanceEvent$, destroyedEvent$);
+                            });
+                            const advanceSubs = forkJoin(...advanceArr$)
+                                .pipe(takeUntil(merge(destroyedEvent$, backEvent$)))
+                                .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);
+                                }
+                                else {
+                                    this.shepherdTour.next();
+                                }
+                                forwardEvent$.next();
+                                advanceSubs.unsubscribe();
+                            });
+                        }
+                        // if abortOn was passed on the step, we bind the event and execute complete
+                        if (step.abortOn) {
+                            const abortArr$ = [];
+                            step.abortOn.forEach((abortOn) => {
+                                const abortEvent$ = new Subject();
+                                abortArr$.push(abortEvent$);
+                                this._bindEvent(abortOn, undefined, abortEvent$, destroyedEvent$);
+                            });
+                            const abortSubs = merge(...abortArr$)
+                                .pipe(takeUntil(merge(destroyedEvent$, backEvent$, forwardEvent$)))
+                                .subscribe(() => {
+                                this.shepherdTour.complete();
+                                abortSubs.unsubscribe();
+                            });
+                        }
+                    };
+                    const _stopTimer$ = new Subject();
+                    const _retriesReached$ = new Subject();
+                    const _retryAttempts$ = new BehaviorSubject(-1);
+                    let id;
+                    // checks if "attachTo" is a string or an object to get the id of an element
+                    if (typeof step.attachTo === 'string') {
+                        id = step.attachTo;
+                    }
+                    else if (typeof step.attachTo === 'object' &&
+                        typeof step.attachTo.element === 'string') {
+                        id = step.attachTo.element;
+                    }
+                    // if we have an id as a string in either case, we use it (we ignore it if its HTMLElement)
+                    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() ===
+                            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((val) => {
+                            if (step.attachToOptions &&
+                                step.attachToOptions.retries !== undefined) {
+                                return val < step.attachToOptions.retries;
+                            }
+                            return val < SHEPHERD_DEFAULT_FIND_ATTEMPTS;
+                        }))
+                            .subscribe((attempts) => {
+                            _retriesReached$.next(1);
+                            _retriesReached$.complete();
+                            // if attempts have been reached, we check "skipIfNotFound" to move on to the next step
+                            if (step.attachToOptions &&
+                                step.attachToOptions.skipIfNotFound) {
+                                // if we get to this step coming back from a step and it wasnt found
+                                // 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 (this.shepherdTour.steps.indexOf(this.shepherdTour.getCurrentStep()) === 0) {
+                                        this.shepherdTour.next();
+                                    }
+                                    else {
+                                        this.shepherdTour.back();
+                                    }
+                                    _backFlow = false;
+                                }
+                                else {
+                                    // destroys current step if we need to skip it to remove it from the tour
+                                    const currentStep = this.shepherdTour.getCurrentStep();
+                                    currentStep?.destroy();
+                                    this.shepherdTour.next();
+                                    this.shepherdTour.removeStep(currentStep?.id ?? '');
+                                }
+                            }
+                            else if (step.attachToOptions && step.attachToOptions.else) {
+                                // if "skipIfNotFound" is not true, then we check if "else" has been set to jump to a specific step
+                                this.shepherdTour.show(step.attachToOptions.else);
+                            }
+                            else {
+                                // tslint:disable-next-line:no-console
+                                console.warn(`Retries reached trying to find ${id}. Retried  ${attempts} times.`);
+                                // 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(() => {
+                            const element = document.querySelector(id ?? '');
+                            // if the element has been found, we stop the timer and resolve the promise
+                            if (element) {
+                                _stopTimer$.next();
+                                _stopTimer$.complete();
+                                additionalCapabilitiesSetup();
+                                resolve();
+                            }
+                            else {
+                                _retryAttempts$.next(_retryAttempts$.value + 1);
+                            }
+                        });
+                        // stop find interval if user stops the tour
+                        destroyedEvent$.subscribe(() => {
+                            _stopTimer$.next();
+                            _stopTimer$.complete();
+                            _retriesReached$.next(1);
+                            _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(() => {
+                            resolve();
+                        });
+                    }
+                });
+            };
+        });
+        return steps;
+    }
+    _bindEvent(eventOn, eventOnOptions, event$, destroyedEvent$) {
+        const selector = eventOn.selector ?? '';
+        const event = eventOn.event;
+        // we start a timer of attempts to find an element in the dom
+        const timerSubs = timer((eventOnOptions && eventOnOptions.timeBeforeShow) ||
+            SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW, (eventOnOptions && eventOnOptions.interval) ||
+            SHEPHERD_DEFAULT_FIND_INTERVAL)
+            .pipe(takeUntil(destroyedEvent$))
+            .subscribe(() => {
+            const element = document.querySelector(selector);
+            // if the element has been found, we stop the timer and resolve the promise
+            if (element) {
+                timerSubs.unsubscribe();
+                if (event === ITourEvent.added) {
+                    // if event is "Added" trigger a soon as this is attached.
+                    event$.next();
+                    event$.complete();
+                }
+                else if (event === ITourEvent.click ||
+                    event === ITourEvent.pointerover ||
+                    (event && event.indexOf(ITourEvent.keyup) > -1)) {
+                    // we use normal listeners for mouseevents
+                    const mainEvent = event?.split('.')[0];
+                    const subEvent = event?.split('.')[1];
+                    fromEvent(element, mainEvent)
+                        .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) {
+                                return true;
+                            }
+                            return false;
+                        }
+                        else {
+                            return true;
+                        }
+                    }))
+                        .subscribe(() => {
+                        event$.next();
+                        event$.complete();
+                    });
+                }
+                else if (event === ITourEvent.removed) {
+                    // and we will use MutationObserver for DOM events
+                    const observer = new MutationObserver(() => {
+                        if (!document.body.contains(element)) {
+                            event$.next();
+                            event$.complete();
+                            observer.disconnect();
+                        }
+                    });
+                    // stop listenining if tour is closed
+                    destroyedEvent$.subscribe(() => {
+                        observer.disconnect();
+                    });
+                    // observe for any DOM interaction in the element
+                    observer.observe(element, {
+                        childList: true,
+                        subtree: true,
+                        attributes: true,
+                    });
+                }
+            }
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guided.tour.js","sourceRoot":"","sources":["../../../../../libs/angular-guided-tour/src/lib/guided.tour.ts"],"names":[],"mappings":"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","sourcesContent":["import Shepherd from 'shepherd.js';\nimport {\n  timer,\n  Subject,\n  BehaviorSubject,\n  merge,\n  Subscription,\n  fromEvent,\n  forkJoin,\n} from 'rxjs';\nimport { takeUntil, skipWhile, filter, skip, first } from 'rxjs/operators';\n\nexport type TourStep = Shepherd.Step.StepOptions;\nexport type TourStepButton = Shepherd.Step.StepOptionsButton;\n\nexport enum ITourEvent {\n  'click' = 'click',\n  'pointerover' = 'pointerover',\n  'keyup' = 'keyup',\n  'added' = 'added', // added to DOM\n  'removed' = 'removed', // removed from DOM\n}\n\nexport interface ITourEventOn {\n  selector?: string; // css selector\n  event?: keyof typeof ITourEvent; // click, pointerover, keyup, added, removed\n}\n\nexport interface ITourEventOnOptions {\n  timeBeforeShow?: number; // delay before step is displayed\n  interval?: number; // time between searches for element, defaults to 500ms\n}\n\nexport interface ITourOptions extends Shepherd.Tour.TourOptions {\n  abortOn?: ITourEventOn[]; // events to abort on\n}\n\nexport interface ITourStepAttachToOptions extends ITourEventOnOptions {\n  highlight?: boolean;\n  retries?: number; // # num of attempts to find element\n  skipIfNotFound?: boolean; // if element is not found after n retries, move on to next step\n  else?: string; // if element is not found, go to step with this id\n  goBackTo?: string; // back button goes back to step with this id\n  skipFromStepCount?: boolean; // show/hide progress on step\n}\n\nexport interface ITourStepAdvanceOnOptions extends ITourEventOnOptions {\n  jumpTo?: string; // next button will jump to step with this id\n  allowGoBack?: boolean; // allow back within this step\n}\n\nexport interface ITourStep extends TourStep {\n  attachToOptions?: ITourStepAttachToOptions;\n  advanceOnOptions?: ITourStepAdvanceOnOptions;\n  advanceOn?: ITourEventOn[] | ITourEventOn | any;\n  abortOn?: ITourEventOn[];\n  count?: number;\n}\n\nabstract class TourButtonsActions {\n  abstract next(): void;\n\n  abstract back(): void;\n\n  abstract cancel(): void;\n\n  abstract finish(): void;\n}\n\nconst SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW = 100;\nconst SHEPHERD_DEFAULT_FIND_INTERVAL = 500;\nconst SHEPHERD_DEFAULT_FIND_ATTEMPTS = 20;\n\nconst overriddenEvents: string[] = [\n  ITourEvent.click,\n  ITourEvent.pointerover,\n  ITourEvent.removed,\n  ITourEvent.added,\n  ITourEvent.keyup,\n];\n\nconst keyEvents: Map<number, string> = new Map<number, string>([\n  [13, 'enter'],\n  [27, 'esc'],\n]);\n\nconst defaultStepOptions: TourStep = {\n  scrollTo: { behavior: 'smooth', block: 'center' },\n  cancelIcon: {\n    enabled: true,\n  },\n};\n\nconst MAT_ICON_BUTTON = 'mat-icon-button material-icons mat-button-base';\nconst MAT_BUTTON = 'mat-button-base mat-button';\nconst MAT_BUTTON_INVISIBLE = 'shepherd-void-button';\n\nexport class CovalentGuidedTour extends TourButtonsActions {\n  private _destroyedEvent$!: Subject<void>;\n\n  shepherdTour!: Shepherd.Tour;\n  stepOptions: ITourStep;\n\n  constructor(stepOptions: ITourStep = defaultStepOptions) {\n    super();\n\n    this.stepOptions = stepOptions;\n    this.newTour();\n  }\n\n  newTour(opts?: ITourOptions): void {\n    this.shepherdTour = new Shepherd.Tour(\n      Object.assign(\n        {\n          defaultStepOptions: this.stepOptions,\n        },\n        opts\n      )\n    );\n\n    this._destroyedEvent$ = new Subject<void>();\n    // listen to cancel and complete to clean up abortOn events\n    merge(\n      fromEvent(this.shepherdTour, 'cancel'),\n      fromEvent(this.shepherdTour, 'complete')\n    )\n      .pipe(first())\n      .subscribe(() => {\n        this._destroyedEvent$.next();\n        this._destroyedEvent$.complete();\n      });\n\n    // if abortOn was passed, we bind the event and execute complete\n    if (opts && opts.abortOn) {\n      const abortArr$: Subject<void>[] = [];\n      opts.abortOn.forEach((abortOn: ITourEventOn) => {\n        const abortEvent$: Subject<void> = new Subject<void>();\n        abortArr$.push(abortEvent$);\n        this._bindEvent(abortOn, undefined, abortEvent$, this._destroyedEvent$);\n      });\n\n      const abortSubs: Subscription = merge(...abortArr$)\n        .pipe(takeUntil(this._destroyedEvent$))\n        .subscribe(() => {\n          this.shepherdTour.complete();\n          abortSubs.unsubscribe();\n        });\n    }\n  }\n\n  back(): void {\n    this.shepherdTour.back();\n  }\n\n  cancel(): void {\n    this.shepherdTour.cancel();\n  }\n\n  next(): void {\n    this.shepherdTour.next();\n  }\n\n  finish(): void {\n    this.shepherdTour.complete();\n  }\n\n  addSteps(steps: ITourStep[]): void {\n    this.shepherdTour.addSteps(this._prepareTour(steps));\n  }\n\n  start(): void {\n    this.shepherdTour.start();\n  }\n\n  protected _prepareTour(\n    originalSteps: ITourStep[],\n    finishLabel: string = 'finish'\n  ): ITourStep[] {\n    // create Subjects for back and forward events\n    const backEvent$: Subject<void> = new Subject<void>();\n    const forwardEvent$: Subject<void> = new Subject<void>();\n    let _backFlow = false;\n    // create Subject for your end\n    const destroyedEvent$: Subject<void> = new Subject<void>();\n    /**\n     * This function adds the step progress in the footer of the shepherd tooltip\n     */\n    const appendProgressFunc = function (this: any): void {\n      // get all the footers that are available in the DOM\n      const footers: Element[] = Array.from<Element>(\n        document.querySelectorAll('.shepherd-footer')\n      );\n      // get the last footer since Shepherd always puts the active one at the end\n      const footer: Element = footers[footers.length - 1];\n      // generate steps html element\n      const progress: HTMLSpanElement = document.createElement('span');\n      progress.className = 'shepherd-progress';\n      progress.innerText = `${this.shepherdTour.currentStep.options.count}/${stepTotal}`;\n      // insert into the footer before the first button\n      footer.insertBefore(progress, footer.querySelector('.shepherd-button'));\n    };\n\n    let stepTotal = 0;\n    const steps: ITourStep[] = originalSteps.map((step: ITourStep) => {\n      let showProgress: () => void = () => {\n        //\n      };\n      if (step.attachToOptions?.skipFromStepCount === true) {\n        showProgress = function (): void {\n          return;\n        };\n      } else if (\n        step.attachToOptions?.skipFromStepCount === undefined ||\n        step.attachToOptions?.skipFromStepCount === false\n      ) {\n        step.count = ++stepTotal;\n        showProgress = appendProgressFunc.bind(this);\n      }\n      return Object.assign({}, step, {\n        when: {\n          show: showProgress,\n        },\n      });\n    });\n\n    const finishButton: TourStepButton = {\n      text: finishLabel,\n      action: this['finish'].bind(this),\n      classes: MAT_BUTTON,\n    };\n\n    const voidButton: TourStepButton = {\n      text: '',\n      action(): void {\n        return;\n      },\n      classes: MAT_BUTTON_INVISIBLE,\n    };\n\n    // listen to the destroyed event to clean up all the streams\n    this._destroyedEvent$.pipe(first()).subscribe(() => {\n      backEvent$.complete();\n      forwardEvent$.complete();\n      destroyedEvent$.next();\n      destroyedEvent$.complete();\n    });\n\n    const totalSteps: number = steps.length;\n    steps.forEach((step: ITourStep, index: number) => {\n      // create buttons specific for the step\n      // this is done to create more control on events\n      const nextButton: TourStepButton = {\n        text: 'chevron_right',\n        action: () => {\n          // intercept the next action and trigger event\n          forwardEvent$.next();\n          this.shepherdTour.next();\n        },\n        classes: MAT_ICON_BUTTON,\n      };\n      const backButton: TourStepButton = {\n        text: 'chevron_left',\n        action: () => {\n          // intercept the back action and trigger event\n          backEvent$.next();\n          _backFlow = true;\n          // check if 'goBackTo' is set to jump to a particular step, else just go back\n          if (step.attachToOptions && step.attachToOptions.goBackTo) {\n            this.shepherdTour.show(step.attachToOptions.goBackTo, false);\n          } else {\n            this.shepherdTour.back();\n          }\n        },\n        classes:\n          step.advanceOnOptions?.allowGoBack === false\n            ? MAT_BUTTON_INVISIBLE\n            : MAT_ICON_BUTTON,\n      };\n\n      // check if highlight was provided for the step, else fallback into shepherds usage\n      step.highlightClass =\n        step.attachToOptions && step.attachToOptions.highlight\n          ? 'shepherd-highlight'\n          : step.highlightClass;\n\n      // Adding buttons in the steps if no buttons are defined\n      if (!step.buttons || step.buttons.length === 0) {\n        if (index === 0) {\n          // first step\n          step.buttons = [nextButton];\n        } else if (index === totalSteps - 1) {\n          // last step\n          step.buttons = [backButton, finishButton];\n        } else {\n          step.buttons = [backButton, nextButton];\n        }\n      }\n\n      // checks \"advanceOn\" to override listeners\n      let advanceOn: ITourEventOn[] | ITourEventOn = step.advanceOn;\n      // remove the shepherd \"advanceOn\" infavor of ours if the event is part of our list\n      if (\n        (typeof advanceOn === 'object' &&\n          !Array.isArray(advanceOn) &&\n          advanceOn.event &&\n          overriddenEvents.indexOf(advanceOn.event.split('.')[0]) > -1) ||\n        advanceOn instanceof Array\n      ) {\n        step.advanceOn = undefined;\n        step.buttons =\n          step.advanceOnOptions && step.advanceOnOptions.allowGoBack\n            ? [backButton, voidButton]\n            : [voidButton];\n      }\n      // adds a default beforeShowPromise function\n      step.beforeShowPromise = () => {\n        return new Promise((resolve: (value?: any) => void) => {\n          const additionalCapabilitiesSetup: () => void = () => {\n            if (advanceOn && !step.advanceOn) {\n              if (!Array.isArray(advanceOn)) {\n                advanceOn = [advanceOn];\n              }\n\n              const advanceArr$: Subject<void>[] = [];\n              advanceOn.forEach((_: any, i: number) => {\n                const advanceEvent$: Subject<void> = new Subject<void>();\n                advanceArr$.push(advanceEvent$);\n\n                // we start a timer of attempts to find an element in the dom\n                this._bindEvent(\n                  _,\n                  step.advanceOnOptions,\n                  advanceEvent$,\n                  destroyedEvent$\n                );\n              });\n              const advanceSubs: Subscription = forkJoin(...advanceArr$)\n                .pipe(takeUntil(merge(destroyedEvent$, backEvent$)))\n                .subscribe(() => {\n                  // check if we need to advance to a specific step, else advance to next step\n                  if (step.advanceOnOptions && step.advanceOnOptions.jumpTo) {\n                    this.shepherdTour.show(step.advanceOnOptions.jumpTo);\n                  } else {\n                    this.shepherdTour.next();\n                  }\n                  forwardEvent$.next();\n                  advanceSubs.unsubscribe();\n                });\n            }\n\n            // if abortOn was passed on the step, we bind the event and execute complete\n            if (step.abortOn) {\n              const abortArr$: Subject<void>[] = [];\n              step.abortOn.forEach((abortOn: ITourEventOn) => {\n                const abortEvent$: Subject<void> = new Subject<void>();\n                abortArr$.push(abortEvent$);\n                this._bindEvent(\n                  abortOn,\n                  undefined,\n                  abortEvent$,\n                  destroyedEvent$\n                );\n              });\n\n              const abortSubs: Subscription = merge(...abortArr$)\n                .pipe(\n                  takeUntil(merge(destroyedEvent$, backEvent$, forwardEvent$))\n                )\n                .subscribe(() => {\n                  this.shepherdTour.complete();\n                  abortSubs.unsubscribe();\n                });\n            }\n          };\n\n          const _stopTimer$: Subject<void> = new Subject<void>();\n          const _retriesReached$: Subject<number> = new Subject<number>();\n          const _retryAttempts$: BehaviorSubject<number> =\n            new BehaviorSubject<number>(-1);\n\n          let id: string | undefined;\n          // checks if \"attachTo\" is a string or an object to get the id of an element\n          if (typeof step.attachTo === 'string') {\n            id = step.attachTo;\n          } else if (\n            typeof step.attachTo === 'object' &&\n            typeof step.attachTo.element === 'string'\n          ) {\n            id = step.attachTo.element;\n          }\n          // if we have an id as a string in either case, we use it (we ignore it if its HTMLElement)\n          if (id) {\n            // if current step is the first step of the tour, we set the buttons to be only \"next\"\n            // 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\n            if (\n              this.shepherdTour.getCurrentStep() ===\n              (<any>this.shepherdTour).steps[0]\n            ) {\n              this.shepherdTour.getCurrentStep()?.updateStepOptions({\n                buttons: originalSteps[index].advanceOn\n                  ? [voidButton]\n                  : [nextButton],\n              });\n            }\n            // register to the attempts observable to notify deeveloper when number has been reached\n            _retryAttempts$\n              .pipe(\n                skip(1),\n                takeUntil(merge(_stopTimer$.asObservable(), destroyedEvent$)),\n                skipWhile((val: number) => {\n                  if (\n                    step.attachToOptions &&\n                    step.attachToOptions.retries !== undefined\n                  ) {\n                    return val < step.attachToOptions.retries;\n                  }\n                  return val < SHEPHERD_DEFAULT_FIND_ATTEMPTS;\n                })\n              )\n              .subscribe((attempts: number) => {\n                _retriesReached$.next(1);\n                _retriesReached$.complete();\n                // if attempts have been reached, we check \"skipIfNotFound\" to move on to the next step\n                if (\n                  step.attachToOptions &&\n                  step.attachToOptions.skipIfNotFound\n                ) {\n                  // if we get to this step coming back from a step and it wasnt found\n                  // then we either check if its the first step and try going forward\n                  // or we keep going back until we find a step that actually exists\n                  if (_backFlow) {\n                    if (\n                      (<any>this.shepherdTour).steps.indexOf(\n                        this.shepherdTour.getCurrentStep()\n                      ) === 0\n                    ) {\n                      this.shepherdTour.next();\n                    } else {\n                      this.shepherdTour.back();\n                    }\n                    _backFlow = false;\n                  } else {\n                    // destroys current step if we need to skip it to remove it from the tour\n                    const currentStep = this.shepherdTour.getCurrentStep();\n                    currentStep?.destroy();\n                    this.shepherdTour.next();\n                    this.shepherdTour.removeStep(currentStep?.id ?? '');\n                  }\n                } else if (step.attachToOptions && step.attachToOptions.else) {\n                  // if \"skipIfNotFound\" is not true, then we check if \"else\" has been set to jump to a specific step\n                  this.shepherdTour.show(step.attachToOptions.else);\n                } else {\n                  // tslint:disable-next-line:no-console\n                  console.warn(\n                    `Retries reached trying to find ${id}. Retried  ${attempts} times.`\n                  );\n                  // else we show the step regardless\n                  resolve();\n                }\n              });\n\n            // we start a timer of attempts to find an element in the dom\n            timer(\n              (step.attachToOptions && step.attachToOptions.timeBeforeShow) ||\n                SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW,\n              (step.attachToOptions && step.attachToOptions.interval) ||\n                SHEPHERD_DEFAULT_FIND_INTERVAL\n            )\n              .pipe(\n                // the timer will continue either until we find the element or the number of attempts has been reached\n                takeUntil(merge(_stopTimer$, _retriesReached$, destroyedEvent$))\n              )\n              .subscribe(() => {\n                const element = document.querySelector(id ?? '');\n                // if the element has been found, we stop the timer and resolve the promise\n                if (element) {\n                  _stopTimer$.next();\n                  _stopTimer$.complete();\n                  additionalCapabilitiesSetup();\n                  resolve();\n                } else {\n                  _retryAttempts$.next(_retryAttempts$.value + 1);\n                }\n              });\n\n            // stop find interval if user stops the tour\n            destroyedEvent$.subscribe(() => {\n              _stopTimer$.next();\n              _stopTimer$.complete();\n              _retriesReached$.next(1);\n              _retriesReached$.complete();\n            });\n          } else {\n            // resolve observable until the timeBeforeShow has passsed or use default\n            timer(\n              (step.attachToOptions && step.attachToOptions.timeBeforeShow) ||\n                SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW\n            )\n              .pipe(takeUntil(merge(destroyedEvent$)))\n              .subscribe(() => {\n                resolve();\n              });\n          }\n        });\n      };\n    });\n    return steps;\n  }\n\n  private _bindEvent(\n    eventOn: ITourEventOn,\n    eventOnOptions: ITourEventOnOptions | undefined,\n    event$: Subject<void>,\n    destroyedEvent$: Subject<void>\n  ): void {\n    const selector = eventOn.selector ?? '';\n    const event = eventOn.event;\n    // we start a timer of attempts to find an element in the dom\n    const timerSubs: Subscription = timer(\n      (eventOnOptions && eventOnOptions.timeBeforeShow) ||\n        SHEPHERD_DEFAULT_FIND_TIME_BEFORE_SHOW,\n      (eventOnOptions && eventOnOptions.interval) ||\n        SHEPHERD_DEFAULT_FIND_INTERVAL\n    )\n      .pipe(takeUntil(destroyedEvent$))\n      .subscribe(() => {\n        const element = document.querySelector(selector);\n        // if the element has been found, we stop the timer and resolve the promise\n        if (element) {\n          timerSubs.unsubscribe();\n\n          if (event === ITourEvent.added) {\n            // if event is \"Added\" trigger a soon as this is attached.\n            event$.next();\n            event$.complete();\n          } else if (\n            event === ITourEvent.click ||\n            event === ITourEvent.pointerover ||\n            (event && event.indexOf(ITourEvent.keyup) > -1)\n          ) {\n            // we use normal listeners for mouseevents\n            const mainEvent = event?.split('.')[0];\n            const subEvent = event?.split('.')[1];\n            fromEvent(element, mainEvent)\n              .pipe(\n                takeUntil(merge(event$.asObservable(), destroyedEvent$)),\n                filter(($event: Event) => {\n                  // only trigger if the event is a keyboard event and part of out list\n                  if ($event instanceof KeyboardEvent) {\n                    if (keyEvents.get($event.keyCode) === subEvent) {\n                      return true;\n                    }\n                    return false;\n                  } else {\n                    return true;\n                  }\n                })\n              )\n              .subscribe(() => {\n                event$.next();\n                event$.complete();\n              });\n          } else if (event === ITourEvent.removed) {\n            // and we will use MutationObserver for DOM events\n            const observer: MutationObserver = new MutationObserver(() => {\n              if (!document.body.contains(element)) {\n                event$.next();\n                event$.complete();\n                observer.disconnect();\n              }\n            });\n\n            // stop listenining if tour is closed\n            destroyedEvent$.subscribe(() => {\n              observer.disconnect();\n            });\n            // observe for any DOM interaction in the element\n            observer.observe(element, {\n              childList: true,\n              subtree: true,\n              attributes: true,\n            });\n          }\n        }\n      });\n  }\n}\n"]}

package/esm2020/public_api.mjs

@@ -0,0 +1,4 @@
+export * from './lib/guided-tour.module';
+export * from './lib/guided-tour.service';
+export * from './lib/guided.tour';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL2xpYnMvYW5ndWxhci1ndWlkZWQtdG91ci9zcmMvcHVibGljX2FwaS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vbGliL2d1aWRlZC10b3VyLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9ndWlkZWQtdG91ci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2d1aWRlZC50b3VyJztcbiJdfQ==