@covalent/guided-tour 4.0.0-beta.4 → 4.1.0-develop.11

package/README.md

@@ -6,15 +6,15 @@ A wrapper around [Shepherd](https://shepherdjs.dev) with extra functionality. Ma
 
 #### Methods
 
-+ registerTour(tourName: string, tour: IGuidedTour | string): Promise<void>
-  + Create a tour
-+ startTour(tourName: string): Shepherd.Tour
-  + Start a certain tour
-+ initializeOnQueryParams(queryParam: string = 'tour'): Observable<ParamMap>
-  + Listen to query params to launch a tour
-+ tourEvent$(str: TourEvents): Observable<IGuidedTourEvent>
-  + Observable of tour events
-  
+- registerTour(tourName: string, tour: IGuidedTour | string): Promise<void>
+  - Create a tour
+- startTour(tourName: string): Shepherd.Tour
+  - Start a certain tour
+- initializeOnQueryParams(queryParam: string = 'tour'): Observable<ParamMap>
+  - Listen to query params to launch a tour
+- tourEvent$(str: TourEvents): Observable<IGuidedTourEvent>
+  - Observable of tour events
+
 ```ts
 // for reference
 export type TourStep = Shepherd.Step.StepOptions;
@@ -105,6 +105,7 @@ import { CovalentGuidedTourModule } from '@covalent/guided-tour';
 ```
 
 ## Usage
+
 ```ts
 import { CovalentGuidedTourService } from '@covalent/guided-tour';
 
@@ -139,16 +140,32 @@ const basicDemoTour: IGuidedTour = {
 };
 this._guidedTourService.registerTour('basicDemoTour', basicDemoTour);
 this._guidedTourService.startTour('basicDemoTour');
-this._guidedTourService.tourEvent$(TourEvents.show)
-  .subscribe((event: IGuidedTourEvent) => { /* event object contains current step, previous step and tour objects */});
+this._guidedTourService
+  .tourEvent$(TourEvents.show)
+  .subscribe((event: IGuidedTourEvent) => {
+    /* event object contains current step, previous step and tour objects */
+  });
 ```
 
 ```html
 <div id="basic-demo">
-  <button mat-raised-button color="accent" (click)="startTour()">Start tour</button>
-  <meter id="fuel" min="0" max="100" low="33" high="66" optimum="50" value="50"></meter>
-  <progress id="oxygen" max="100" value="70"> 70% </progress>
+  <button mat-raised-button color="accent" (click)="startTour()">
+    Start tour
+  </button>
+  <meter
+    id="fuel"
+    min="0"
+    max="100"
+    low="33"
+    high="66"
+    optimum="50"
+    value="50"
+  ></meter>
+  <progress id="oxygen" max="100" value="70">70%</progress>
   <marquee id="status">All systems are running smoothly</marquee>
 </div>
-
 ```
+
+## Running unit tests
+
+Run `nx test angular-guided-tour` to execute the unit tests.

package/_guided-tour-theme.scss

@@ -1,5 +1,3 @@
-@import './guided-tour.scss';
-
 @mixin covalent-guided-tour-theme($theme, $config: null) {
   @include td-guided-tour-typography($config);
   @include td-guided-tour-theme($theme);
@@ -56,7 +54,8 @@
   .shepherd-arrow::before,
   .shepherd-arrow::after,
   .shepherd-content,
-  .shepherd-element.shepherd-has-title[data-popper-placement^='bottom'] > .shepherd-arrow::before {
+  .shepherd-element.shepherd-has-title[data-popper-placement^='bottom']
+    > .shepherd-arrow::before {
     background: mat-color($accent, darker);
   }
 

package/covalent-guided-tour.d.ts

@@ -2,4 +2,4 @@
  * Generated bundle index. Do not edit.
  */
 /// <amd-module name="@covalent/guided-tour" />
-export * from './index';
+export * from './public_api';

package/esm2020/covalent-guided-tour.mjs

@@ -1,5 +1,5 @@
 /**
  * Generated bundle index. Do not edit.
  */
-export * from './index';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtZ3VpZGVkLXRvdXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvcGxhdGZvcm0vZ3VpZGVkLXRvdXIvY292YWxlbnQtZ3VpZGVkLXRvdXIudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLFNBQVMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogR2VuZXJhdGVkIGJ1bmRsZSBpbmRleC4gRG8gbm90IGVkaXQuXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9pbmRleCc7XG4iXX0=
+export * from './public_api';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY292YWxlbnQtZ3VpZGVkLXRvdXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9saWJzL2FuZ3VsYXItZ3VpZGVkLXRvdXIvc3JjL2NvdmFsZW50LWd1aWRlZC10b3VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBRUgsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEdlbmVyYXRlZCBidW5kbGUgaW5kZXguIERvIG5vdCBlZGl0LlxuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vcHVibGljX2FwaSc7XG4iXX0=

package/esm2020/lib/guided-tour.module.mjs

@@ -0,0 +1,19 @@
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+import { CovalentGuidedTourService } from './guided-tour.service';
+import * as i0 from "@angular/core";
+export class CovalentGuidedTourModule {
+}
+CovalentGuidedTourModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+CovalentGuidedTourModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourModule, imports: [CommonModule] });
+CovalentGuidedTourModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourModule, providers: [CovalentGuidedTourService], imports: [[CommonModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule],
+                    providers: [CovalentGuidedTourService],
+                    declarations: [],
+                    exports: [],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ3VpZGVkLXRvdXIubW9kdWxlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vbGlicy9hbmd1bGFyLWd1aWRlZC10b3VyL3NyYy9saWIvZ3VpZGVkLXRvdXIubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxRQUFRLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDekMsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLGlCQUFpQixDQUFDO0FBQy9DLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQVFsRSxNQUFNLE9BQU8sd0JBQXdCOztxSEFBeEIsd0JBQXdCO3NIQUF4Qix3QkFBd0IsWUFMekIsWUFBWTtzSEFLWCx3QkFBd0IsYUFKeEIsQ0FBQyx5QkFBeUIsQ0FBQyxZQUQ3QixDQUFDLFlBQVksQ0FBQzsyRkFLWix3QkFBd0I7a0JBTnBDLFFBQVE7bUJBQUM7b0JBQ1IsT0FBTyxFQUFFLENBQUMsWUFBWSxDQUFDO29CQUN2QixTQUFTLEVBQUUsQ0FBQyx5QkFBeUIsQ0FBQztvQkFDdEMsWUFBWSxFQUFFLEVBQUU7b0JBQ2hCLE9BQU8sRUFBRSxFQUFFO2lCQUNaIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgTmdNb2R1bGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcbmltcG9ydCB7IENvbW1vbk1vZHVsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvbW1vbic7XG5pbXBvcnQgeyBDb3ZhbGVudEd1aWRlZFRvdXJTZXJ2aWNlIH0gZnJvbSAnLi9ndWlkZWQtdG91ci5zZXJ2aWNlJztcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZV0sXG4gIHByb3ZpZGVyczogW0NvdmFsZW50R3VpZGVkVG91clNlcnZpY2VdLFxuICBkZWNsYXJhdGlvbnM6IFtdLFxuICBleHBvcnRzOiBbXSxcbn0pXG5leHBvcnQgY2xhc3MgQ292YWxlbnRHdWlkZWRUb3VyTW9kdWxlIHt9XG4iXX0=

package/esm2020/lib/guided-tour.service.mjs

@@ -0,0 +1,163 @@
+import { Injectable } from '@angular/core';
+import { HttpClient } from '@angular/common/http';
+import { Router, ActivatedRoute, NavigationStart, } from '@angular/router';
+import { tap, map, filter } from 'rxjs/operators';
+import { fromEvent } from 'rxjs';
+import { debounceTime } from 'rxjs/operators';
+import { CovalentGuidedTour, } from './guided.tour';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/router";
+import * as i2 from "@angular/common/http";
+/**
+ *  Router enabled Shepherd tour
+ */
+export 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 = {}));
+export class CovalentGuidedTourService extends CovalentGuidedTour {
+    constructor(_router, _route, _httpClient) {
+        super();
+        this._router = _router;
+        this._route = _route;
+        this._httpClient = _httpClient;
+        this._toursMap = new Map();
+        this._tourStepURLs = new Map();
+        _router.events
+            .pipe(filter((event) => event instanceof NavigationStart &&
+            event.navigationTrigger === 'popstate'))
+            .subscribe(() => {
+            if (this.shepherdTour.isActive()) {
+                this.shepherdTour.cancel();
+            }
+        });
+    }
+    tourEvent$(str) {
+        return fromEvent(this.shepherdTour, str);
+    }
+    async registerTour(tourName, tour) {
+        const guidedTour = typeof tour === 'string' ? await this._loadTour(tour) : tour;
+        this._toursMap.set(tourName, guidedTour);
+    }
+    startTour(tourName) {
+        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 }));
+            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((tourEvent) => {
+                const currentURL = this._router.url.split(/[?#]/)[0];
+                const { step: { id, options }, } = tourEvent;
+                if (this._tourStepURLs.has(id)) {
+                    const stepRoute = this._tourStepURLs.get(id);
+                    if (stepRoute !== currentURL) {
+                        this._router.navigate([stepRoute]);
+                    }
+                }
+                else {
+                    if (options && options.routing) {
+                        this._tourStepURLs.set(id, options.routing.route);
+                    }
+                    else {
+                        this._tourStepURLs.set(id, currentURL);
+                    }
+                }
+            });
+            this.start();
+            return tourInstance;
+        }
+        else {
+            // tslint:disable-next-line:no-console
+            console.warn(`Tour ${tourName} does not exist. Please try another tour.`);
+            return undefined;
+        }
+    }
+    // Finds the right registered tour by using queryParams
+    // finishes any other tour and starts the new one.
+    initializeOnQueryParams(queryParam = 'tour') {
+        return this._route.queryParamMap.pipe(debounceTime(100), tap((params) => {
+            const tourParam = params.get(queryParam);
+            if (tourParam) {
+                this.startTour(tourParam);
+                // get current search parameters
+                const searchParams = new URLSearchParams(window.location.search);
+                // delete tour queryParam
+                searchParams.delete(queryParam);
+                // build new URL string without it
+                let url = window.location.protocol +
+                    '//' +
+                    window.location.host +
+                    window.location.pathname;
+                if (searchParams.toString()) {
+                    url += '?' + searchParams.toString();
+                }
+                // replace state in history without triggering a navigation
+                window.history.replaceState({ path: url }, '', url);
+            }
+        }));
+    }
+    setNextBtnDisability(stepId, isDisabled) {
+        if (this.shepherdTour.getById(stepId)) {
+            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);
+        }
+    }
+    async _loadTour(tourUrl) {
+        const request = this._httpClient.get(tourUrl);
+        try {
+            return await request
+                .pipe(map((resultSet) => {
+                return JSON.parse(JSON.stringify(resultSet));
+            }))
+                .toPromise();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    _getTour(key) {
+        return this._toursMap.get(key);
+    }
+    _configureRoutesForSteps(routedSteps) {
+        routedSteps.forEach((step) => {
+            if (step.routing) {
+                const route = step.routing.route;
+                // if there is a beforeShowPromise, then we save it and call it after the navigation
+                if (step.beforeShowPromise) {
+                    const beforeShowPromise = step.beforeShowPromise;
+                    step.beforeShowPromise = () => {
+                        return this._router
+                            .navigate([route], step.routing?.extras)
+                            .then(() => {
+                            return beforeShowPromise();
+                        });
+                    };
+                }
+                else {
+                    step.beforeShowPromise = () => this._router.navigate([route]);
+                }
+            }
+        });
+        return routedSteps;
+    }
+}
+CovalentGuidedTourService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourService, deps: [{ token: i1.Router }, { token: i1.ActivatedRoute }, { token: i2.HttpClient }], target: i0.ɵɵFactoryTarget.Injectable });
+CovalentGuidedTourService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.2", ngImport: i0, type: CovalentGuidedTourService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.Router }, { type: i1.ActivatedRoute }, { type: i2.HttpClient }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"guided-tour.service.js","sourceRoot":"","sources":["../../../../../libs/angular-guided-tour/src/lib/guided-tour.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { HttpClient } from '@angular/common/http';\nimport {\n  Router,\n  ActivatedRoute,\n  ParamMap,\n  NavigationExtras,\n  NavigationStart,\n  Event as NavigationEvent,\n} from '@angular/router';\nimport Shepherd from 'shepherd.js';\nimport { tap, map, filter } from 'rxjs/operators';\nimport { Observable, fromEvent } from 'rxjs';\nimport { debounceTime } from 'rxjs/operators';\nimport {\n  CovalentGuidedTour,\n  ITourStep,\n  ITourOptions,\n  TourStepButton,\n} from './guided.tour';\n\nexport interface IGuidedTour extends ITourOptions {\n  steps: IGuidedTourStep[];\n  finishButtonText?: string;\n}\n\nexport interface IGuidedTourStep extends ITourStep {\n  routing?: {\n    route: string;\n    extras?: NavigationExtras;\n  };\n}\n\n/**\n *  Router enabled Shepherd tour\n */\nexport enum TourEvents {\n  complete = 'complete',\n  cancel = 'cancel',\n  hide = 'hide',\n  show = 'show',\n  start = 'start',\n  active = 'active',\n  inactive = 'inactive',\n}\n\nexport interface IGuidedTourEvent {\n  step: any;\n  previous: any;\n  tour: any;\n}\n\n@Injectable()\nexport class CovalentGuidedTourService extends CovalentGuidedTour {\n  private _toursMap: Map<string, IGuidedTour> = new Map<string, IGuidedTour>();\n  private _tourStepURLs: Map<string, string> = new Map<string, string>();\n  constructor(\n    private _router: Router,\n    private _route: ActivatedRoute,\n    private _httpClient: HttpClient\n  ) {\n    super();\n    _router.events\n      .pipe(\n        filter(\n          (event: NavigationEvent) =>\n            event instanceof NavigationStart &&\n            event.navigationTrigger === 'popstate'\n        )\n      )\n      .subscribe(() => {\n        if (this.shepherdTour.isActive()) {\n          this.shepherdTour.cancel();\n        }\n      });\n  }\n\n  tourEvent$(str: TourEvents): Observable<IGuidedTourEvent> {\n    return fromEvent(this.shepherdTour, str);\n  }\n\n  async registerTour(\n    tourName: string,\n    tour: IGuidedTour | string\n  ): Promise<void> {\n    const guidedTour: IGuidedTour =\n      typeof tour === 'string' ? await this._loadTour(tour) : tour;\n    this._toursMap.set(tourName, guidedTour);\n  }\n\n  startTour(tourName: string): Shepherd.Tour | undefined {\n    const guidedTour = this._getTour(tourName);\n    this.finish();\n    if (guidedTour && guidedTour.steps && guidedTour.steps.length) {\n      // remove steps from tour since we need to preprocess them first\n      this.newTour(Object.assign({}, guidedTour, { steps: undefined }));\n      const tourInstance: Shepherd.Tour = this.shepherdTour.addSteps(\n        this._configureRoutesForSteps(\n          this._prepareTour(guidedTour.steps, guidedTour.finishButtonText)\n        )\n      );\n      // init route transition if step URL is different then the current location.\n      this.tourEvent$(TourEvents.show).subscribe(\n        (tourEvent: IGuidedTourEvent) => {\n          const currentURL: string = this._router.url.split(/[?#]/)[0];\n          const {\n            step: { id, options },\n          } = tourEvent;\n          if (this._tourStepURLs.has(id)) {\n            const stepRoute = this._tourStepURLs.get(id);\n            if (stepRoute !== currentURL) {\n              this._router.navigate([stepRoute]);\n            }\n          } else {\n            if (options && options.routing) {\n              this._tourStepURLs.set(id, options.routing.route);\n            } else {\n              this._tourStepURLs.set(id, currentURL);\n            }\n          }\n        }\n      );\n      this.start();\n      return tourInstance;\n    } else {\n      // tslint:disable-next-line:no-console\n      console.warn(`Tour ${tourName} does not exist. Please try another tour.`);\n      return undefined;\n    }\n  }\n\n  // Finds the right registered tour by using queryParams\n  // finishes any other tour and starts the new one.\n  initializeOnQueryParams(queryParam: string = 'tour'): Observable<ParamMap> {\n    return this._route.queryParamMap.pipe(\n      debounceTime(100),\n      tap((params: ParamMap) => {\n        const tourParam = params.get(queryParam);\n        if (tourParam) {\n          this.startTour(tourParam);\n          // get current search parameters\n          const searchParams: URLSearchParams = new URLSearchParams(\n            window.location.search\n          );\n          // delete tour queryParam\n          searchParams.delete(queryParam);\n          // build new URL string without it\n          let url: string =\n            window.location.protocol +\n            '//' +\n            window.location.host +\n            window.location.pathname;\n          if (searchParams.toString()) {\n            url += '?' + searchParams.toString();\n          }\n          // replace state in history without triggering a navigation\n          window.history.replaceState({ path: url }, '', url);\n        }\n      })\n    );\n  }\n\n  setNextBtnDisability(stepId: string, isDisabled: boolean): void {\n    if (this.shepherdTour.getById(stepId)) {\n      const stepOptions: ITourStep = (this.shepherdTour.getById(stepId) as any)\n        .options;\n      stepOptions.buttons?.forEach((button: TourStepButton) => {\n        if (button.text === 'chevron_right') {\n          button.disabled = isDisabled;\n        }\n      });\n      this.shepherdTour.getById(stepId)?.updateStepOptions(stepOptions);\n    }\n  }\n\n  private async _loadTour(tourUrl: string): Promise<any> {\n    const request: Observable<object> = this._httpClient.get(tourUrl);\n    try {\n      return await request\n        .pipe(\n          map((resultSet: any) => {\n            return JSON.parse(JSON.stringify(resultSet));\n          })\n        )\n        .toPromise();\n    } catch {\n      return undefined;\n    }\n  }\n\n  private _getTour(key: string): IGuidedTour | undefined {\n    return this._toursMap.get(key);\n  }\n\n  private _configureRoutesForSteps(\n    routedSteps: IGuidedTourStep[]\n  ): IGuidedTourStep[] {\n    routedSteps.forEach((step: IGuidedTourStep) => {\n      if (step.routing) {\n        const route: string = step.routing.route;\n        // if there is a beforeShowPromise, then we save it and call it after the navigation\n        if (step.beforeShowPromise) {\n          const beforeShowPromise: () => Promise<void> = step.beforeShowPromise;\n          step.beforeShowPromise = () => {\n            return this._router\n              .navigate([route], step.routing?.extras)\n              .then(() => {\n                return beforeShowPromise();\n              });\n          };\n        } else {\n          step.beforeShowPromise = () => this._router.navigate([route]);\n        }\n      }\n    });\n\n    return routedSteps;\n  }\n}\n"]}