@clr/angular 12.0.11 → 13.0.1

package/esm2020/wizard/providers/wizard-navigation.service.mjs

@@ -0,0 +1,574 @@
+/*
+ * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.
+ * This software is released under MIT license.
+ * The full license information can be found in LICENSE in the root directory of this project.
+ */
+import { Injectable } from '@angular/core';
+import { Subject } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "./page-collection.service";
+import * as i2 from "./button-hub.service";
+/**
+ * Performs navigation functions for a wizard and manages the current page. Presented as a
+ * separate service to encapsulate the behavior of navigating and completing the wizard so
+ * that it can be shared across the wizard and its sub-components.
+ *
+ * The easiest way to access the navigation service is there a reference on your wizard. The
+ * Following example would allow you to access your instance of the wizard from your host
+ * component and thereby access the navigation service via YourHostComponent.wizard.navService.
+ *
+ * @example
+ * <clr-wizard #wizard ...>
+ *
+ * @example
+ * export class YourHostComponent {
+ *   @ViewChild("wizard") wizard: Wizard;
+ *   ...
+ * }
+ *
+ */
+export class WizardNavigationService {
+    /**
+     * Creates an instance of WizardNavigationService. Also sets up subscriptions
+     * that listen to the button service to determine when a button has been clicked
+     * in the wizard. Is also responsible for taking action when the page collection
+     * requests that navigation be reset to its pristine state.
+     *
+     * @memberof WizardNavigationService
+     */
+    constructor(pageCollection, buttonService) {
+        this.pageCollection = pageCollection;
+        this.buttonService = buttonService;
+        /**
+         *
+         * @memberof WizardNavigationService
+         */
+        this._currentChanged = new Subject();
+        /**
+         * A Boolean flag used by the ClrWizardPage to avoid a race condition when pages are
+         * loading and there is no current page defined.
+         *
+         * @memberof WizardNavigationService
+         */
+        this.navServiceLoaded = false;
+        /**
+         * A boolean flag shared across the Wizard subcomponents that follows the value
+         * of the Wizard.forceForward (clrWizardForceForwardNavigation) input. When true,
+         * navigating backwards in the stepnav menu will reset any skipped pages' completed
+         * state to false.
+         *
+         * This is useful when a wizard executes validation on a page-by-page basis when
+         * the next button is clicked.
+         *
+         * @memberof WizardNavigationService
+         */
+        this.forceForwardNavigation = false;
+        /**
+         * @memberof WizardNavigationService
+         */
+        this._movedToNextPage = new Subject();
+        /**
+         * @memberof WizardNavigationService
+         */
+        this._wizardFinished = new Subject();
+        /**
+         * @memberof WizardNavigationService
+         */
+        this._movedToPreviousPage = new Subject();
+        /**
+         * @memberof WizardNavigationService
+         */
+        this._cancelWizard = new Subject();
+        /**
+         * A boolean flag shared across the Wizard subcomponents that follows the value
+         * of the Wizard.stopCancel (clrWizardPreventDefaultCancel) input. When true, the cancel
+         * routine is subverted and must be reinstated in the host component calling Wizard.close()
+         * at some point.
+         *
+         * @memberof WizardNavigationService
+         */
+        this.wizardHasAltCancel = false;
+        /**
+         * A boolean flag shared across the Wizard subcomponents that follows the value
+         * of the Wizard.stopNext (clrWizardPreventDefaultNext) input. When true, the next and finish
+         * routines are subverted and must be reinstated in the host component calling Wizard.next(),
+         * Wizard.forceNext(), Wizard.finish(), or Wizard.forceFinish().
+         *
+         * @memberof WizardNavigationService
+         */
+        this.wizardHasAltNext = false;
+        /**
+         * A boolean flag shared across the Wizard subcomponents that follows the value
+         * of the Wizard.stopNavigation (clrWizardPreventNavigation) input. When true, all
+         * navigational elements in the wizard are disabled.
+         *
+         * This is intended to freeze the wizard in place. Events are not fired so this is
+         * not a way to implement alternate functionality for navigation.
+         *
+         * @memberof WizardNavigationService
+         */
+        this.wizardStopNavigation = false;
+        /**
+         * A boolean flag shared with the stepnav items that prevents user clicks on
+         * stepnav items from navigating the wizard.
+         *
+         * @memberof WizardNavigationService
+         */
+        this.wizardDisableStepnav = false;
+        this.previousButtonSubscription = this.buttonService.previousBtnClicked.subscribe(() => {
+            const currentPage = this.currentPage;
+            if (this.currentPageIsFirst || currentPage.previousStepDisabled) {
+                return;
+            }
+            currentPage.previousButtonClicked.emit(currentPage);
+            if (!currentPage.preventDefault) {
+                this.previous();
+            }
+        });
+        this.nextButtonSubscription = this.buttonService.nextBtnClicked.subscribe(() => {
+            this.checkAndCommitCurrentPage('next');
+        });
+        this.dangerButtonSubscription = this.buttonService.dangerBtnClicked.subscribe(() => {
+            this.checkAndCommitCurrentPage('danger');
+        });
+        this.finishButtonSubscription = this.buttonService.finishBtnClicked.subscribe(() => {
+            this.checkAndCommitCurrentPage('finish');
+        });
+        this.customButtonSubscription = this.buttonService.customBtnClicked.subscribe((type) => {
+            if (!this.wizardStopNavigation) {
+                this.currentPage.customButtonClicked.emit(type);
+            }
+        });
+        this.cancelButtonSubscription = this.buttonService.cancelBtnClicked.subscribe(() => {
+            if (this.wizardStopNavigation) {
+                return;
+            }
+            if (this.currentPage.preventDefault) {
+                this.currentPage.pageOnCancel.emit(this.currentPage);
+            }
+            else {
+                this.cancel();
+            }
+        });
+        this.pagesResetSubscription = this.pageCollection.pagesReset.subscribe(() => {
+            this.setFirstPageCurrent();
+        });
+    }
+    /**
+     *
+     * @memberof WizardNavigationService
+     */
+    ngOnDestroy() {
+        this.previousButtonSubscription.unsubscribe();
+        this.nextButtonSubscription.unsubscribe();
+        this.dangerButtonSubscription.unsubscribe();
+        this.finishButtonSubscription.unsubscribe();
+        this.customButtonSubscription.unsubscribe();
+        this.cancelButtonSubscription.unsubscribe();
+        this.pagesResetSubscription.unsubscribe();
+    }
+    /**
+     * An Observable that is predominantly used amongst the subcomponents and services
+     * of the wizard. It is recommended that users listen to the ClrWizardPage.onLoad
+     * (clrWizardPageOnLoad) output instead of this Observable.
+     *
+     * @memberof WizardNavigationService
+     */
+    get currentPageChanged() {
+        // TODO: MAKE SURE EXTERNAL OUTPUTS SAY 'CHANGE' NOT 'CHANGED'
+        // A BREAKING CHANGE SO AWAITING MINOR RELEASE
+        return this._currentChanged.asObservable();
+    }
+    /**
+     * @memberof WizardNavigationService
+     */
+    get currentPageTitle() {
+        // when the querylist of pages is empty. this is the first place it fails...
+        if (!this.currentPage) {
+            return null;
+        }
+        return this.currentPage.title;
+    }
+    /**
+     * Returns a Boolean that tells you whether or not the current page is the first
+     * page in the Wizard.
+     *
+     * This is helpful for determining whether a page is navigable.
+     *
+     * @memberof WizardNavigationService
+     */
+    get currentPageIsFirst() {
+        return this.pageCollection.firstPage === this.currentPage;
+    }
+    /**
+     * Returns a Boolean that tells you whether or not the current page is the
+     * last page in the Wizard.
+     *
+     * This is used to determine which buttons should display in the wizard footer.
+     *
+     * @memberof WizardNavigationService
+     */
+    get currentPageIsLast() {
+        return this.pageCollection.lastPage === this.currentPage;
+    }
+    /**
+     * Returns the ClrWizardPage object of the current page or null.
+     *
+     * @memberof WizardNavigationService
+     */
+    get currentPage() {
+        if (!this._currentPage) {
+            return null;
+        }
+        return this._currentPage;
+    }
+    /**
+     * Accepts a ClrWizardPage object, since that object to be the current/active
+     * page in the wizard, and emits the ClrWizardPage.onLoad (clrWizardPageOnLoad)
+     * event for that page.
+     *
+     * Note that all of this work is bypassed if the ClrWizardPage object is already
+     * the current page.
+     *
+     * @memberof WizardNavigationService
+     */
+    set currentPage(page) {
+        if (this._currentPage !== page && !this.wizardStopNavigation) {
+            this._currentPage = page;
+            page.onLoad.emit(page.id);
+            this._currentChanged.next(page);
+        }
+    }
+    /**
+     * An observable used internally to alert the wizard that forward navigation
+     * has occurred. It is recommended that you use the Wizard.onMoveNext
+     * (clrWizardOnNext) output instead of this one.
+     *
+     * @memberof WizardNavigationService
+     */
+    get movedToNextPage() {
+        return this._movedToNextPage.asObservable();
+    }
+    /**
+     * An observable used internally to alert the wizard that the nav service
+     * has approved completion of the wizard.
+     *
+     * It is recommended that you use the Wizard.wizardFinished (clrWizardOnFinish)
+     * output instead of this one.
+     *
+     * @memberof WizardNavigationService
+     */
+    get wizardFinished() {
+        return this._wizardFinished.asObservable();
+    }
+    /**
+     * This is a public function that can be used to programmatically advance
+     * the user to the next page.
+     *
+     * When invoked, this method will move the wizard to the next page after
+     * successful validation. Note that this method goes through all checks
+     * and event emissions as if Wizard.next(false) had been called.
+     *
+     * In most cases, it makes more sense to use Wizard.next(false).
+     *
+     * @memberof WizardNavigationService
+     */
+    next() {
+        if (this.currentPageIsLast) {
+            this.checkAndCommitCurrentPage('finish');
+        }
+        else {
+            this.checkAndCommitCurrentPage('next');
+        }
+    }
+    /**
+     * Bypasses checks and most event emissions to force a page to navigate forward.
+     *
+     * Comparable to calling Wizard.next() or Wizard.forceNext().
+     *
+     * @memberof WizardNavigationService
+     */
+    forceNext() {
+        const currentPage = this.currentPage;
+        const nextPage = this.pageCollection.getNextPage(currentPage);
+        // catch errant null or undefineds that creep in
+        if (!nextPage) {
+            throw new Error('The wizard has no next page to go to.');
+        }
+        if (this.wizardStopNavigation) {
+            return;
+        }
+        if (!currentPage.completed) {
+            // this is a state that alt next flows can get themselves in...
+            this.pageCollection.commitPage(currentPage);
+        }
+        this.currentPage = nextPage;
+    }
+    /**
+     * Accepts a button/action type as a parameter. Encapsulates all logic for
+     * event emissions, state of the current page, and wizard and page level overrides.
+     *
+     * Avoid calling this function directly unless you really know what you're doing.
+     *
+     * @memberof WizardNavigationService
+     */
+    checkAndCommitCurrentPage(buttonType) {
+        const currentPage = this.currentPage;
+        if (!currentPage.readyToComplete || this.wizardStopNavigation) {
+            return;
+        }
+        const iAmTheLastPage = this.currentPageIsLast;
+        const isNext = buttonType === 'next';
+        const isDanger = buttonType === 'danger';
+        const isDangerNext = isDanger && !iAmTheLastPage;
+        const isDangerFinish = isDanger && iAmTheLastPage;
+        const isFinish = buttonType === 'finish' || isDangerFinish;
+        if (isFinish && !iAmTheLastPage) {
+            return;
+        }
+        currentPage.primaryButtonClicked.emit(buttonType);
+        if (isFinish) {
+            currentPage.finishButtonClicked.emit(currentPage);
+        }
+        else if (isDanger) {
+            currentPage.dangerButtonClicked.emit();
+        }
+        else if (isNext) {
+            currentPage.nextButtonClicked.emit();
+        }
+        if (currentPage.stopNext || currentPage.preventDefault) {
+            currentPage.onCommit.emit(currentPage.id);
+            return;
+        }
+        // order is very important with these emitters!
+        if (isFinish) {
+            // mark page as complete
+            if (!this.wizardHasAltNext) {
+                this.pageCollection.commitPage(currentPage);
+            }
+            this._wizardFinished.next();
+        }
+        if (this.wizardHasAltNext) {
+            this.pageCollection.commitPage(currentPage);
+            if (isNext || isDangerNext) {
+                this._movedToNextPage.next(true);
+            }
+            // jump out here, no matter what type we're looking at
+            return;
+        }
+        if (isNext || isDangerNext) {
+            this.forceNext();
+        }
+        if (!this.wizardHasAltNext && !this.wizardStopNavigation) {
+            this._movedToNextPage.next(true);
+        }
+    }
+    /**
+     * This is a public function that can be used to programmatically conclude
+     * the wizard.
+     *
+     * When invoked, this method will  initiate the work involved with finalizing
+     * and finishing the wizard workflow. Note that this method goes through all
+     * checks and event emissions as if Wizard.finish(false) had been called.
+     *
+     * In most cases, it makes more sense to use Wizard.finish(false).
+     *
+     * @memberof WizardNavigationService
+     */
+    finish() {
+        this.checkAndCommitCurrentPage('finish');
+    }
+    /**
+     * Notifies the wizard when backwards navigation has occurred via the
+     * previous button.
+     *
+     * @memberof WizardNavigationService
+     */
+    get movedToPreviousPage() {
+        return this._movedToPreviousPage.asObservable();
+    }
+    /**
+     * Programmatically moves the wizard to the page before the current page.
+     *
+     * In most instances, it makes more sense to call Wizard.previous()
+     * which does the same thing.
+     *
+     * @memberof WizardNavigationService
+     */
+    previous() {
+        if (this.currentPageIsFirst || this.wizardStopNavigation) {
+            return;
+        }
+        const previousPage = this.pageCollection.getPreviousPage(this.currentPage);
+        if (!previousPage) {
+            return;
+        }
+        this._movedToPreviousPage.next(true);
+        if (this.forceForwardNavigation) {
+            this.currentPage.completed = false;
+        }
+        this.currentPage = previousPage;
+    }
+    /**
+     * Notifies the wizard that a user is trying to cancel it.
+     *
+     * @memberof WizardNavigationService
+     */
+    get notifyWizardCancel() {
+        return this._cancelWizard.asObservable();
+    }
+    /**
+     * Allows a hook into the cancel workflow of the wizard from the nav service. Note that
+     * this route goes through all checks and event emissions as if a cancel button had
+     * been clicked.
+     *
+     * In most cases, users looking for a hook into the cancel routine are actually looking
+     * for a way to close the wizard from their host component because they have prevented
+     * the default cancel action.
+     *
+     * In this instance, it is recommended that you use Wizard.close() to avoid any event
+     * emission loop resulting from an event handler calling back into routine that will
+     * again evoke the events it handles.
+     *
+     * @memberof WizardNavigationService
+     */
+    cancel() {
+        this._cancelWizard.next();
+    }
+    /**
+     * Performs all required checks to determine if a user can navigate to a page. Checking at each
+     * point if a page is navigable -- completed where the page immediately after the last completed
+     * page.
+     *
+     * Takes two parameters. The first one must be either the ClrWizardPage object or the ID of the
+     * ClrWizardPage object that you want to make the current page.
+     *
+     * The second parameter is optional and is a Boolean flag for "lazy completion". What this means
+     * is the Wizard will mark all pages between the current page and the page you want to navigate
+     * to as completed. This is useful for informational wizards that do not require user action,
+     * allowing an easy means for users to jump ahead.
+     *
+     * To avoid checks on navigation, use ClrWizardPage.makeCurrent() instead.
+     *
+     * @memberof WizardNavigationService
+     */
+    goTo(pageToGoToOrId, lazyComplete = false) {
+        const myPages = this.pageCollection;
+        const pageToGoTo = typeof pageToGoToOrId === 'string' ? myPages.getPageById(pageToGoToOrId) : pageToGoToOrId;
+        const currentPage = this.currentPage;
+        // no point in going to the current page. you're there already!
+        // also hard block on any navigation when stopNavigation is true
+        if (pageToGoTo === currentPage || this.wizardStopNavigation) {
+            return;
+        }
+        const currentPageIndex = myPages.getPageIndex(currentPage);
+        const goToPageIndex = myPages.getPageIndex(pageToGoTo);
+        const goingForward = goToPageIndex > currentPageIndex;
+        const pagesToCheck = myPages.getPageRangeFromPages(this.currentPage, pageToGoTo);
+        const okayToMove = lazyComplete || this.canGoTo(pagesToCheck);
+        if (!okayToMove) {
+            return;
+        }
+        if (goingForward && lazyComplete) {
+            pagesToCheck.forEach((page) => {
+                if (page !== pageToGoTo) {
+                    page.completed = true;
+                }
+            });
+        }
+        else if (!goingForward && this.forceForwardNavigation) {
+            pagesToCheck.forEach((page) => {
+                page.completed = false;
+            });
+        }
+        this.currentPage = pageToGoTo;
+    }
+    /**
+     * Accepts a range of ClrWizardPage objects as a parameter. Performs the work of checking
+     * those objects to determine if navigation can be accomplished.
+     *
+     * @memberof WizardNavigationService
+     */
+    canGoTo(pagesToCheck) {
+        let okayToMove = true;
+        const myPages = this.pageCollection;
+        // previous page can be important when moving because if it's completed it
+        // allows us to move to the page even if it's incomplete...
+        let previousPagePasses;
+        if (!pagesToCheck || pagesToCheck.length < 1) {
+            return false;
+        }
+        pagesToCheck.forEach((page) => {
+            if (!okayToMove) {
+                return;
+            }
+            if (page.completed) {
+                // default is true. just jump out instead of complicating it.
+                return;
+            }
+            // so we know our page is not completed...
+            const previousPage = myPages.getPageIndex(page) > 0 ? myPages.getPreviousPage(page) : null;
+            previousPagePasses = previousPage === null || previousPage.completed === true;
+            // we are false if not the current page AND previous page is not completed
+            // (but must have a previous page)
+            if (!page.current && !previousPagePasses) {
+                okayToMove = false;
+            }
+            // falls through to true as default
+        });
+        return okayToMove;
+    }
+    /**
+     * Looks through the collection of pages to find the first one that is incomplete
+     * and makes that page the current/active page.
+     *
+     * @memberof WizardNavigationService
+     */
+    setLastEnabledPageCurrent() {
+        const allPages = this.pageCollection.pagesAsArray;
+        let lastCompletedPageIndex = null;
+        allPages.forEach((page, index) => {
+            if (page.completed) {
+                lastCompletedPageIndex = index;
+            }
+        });
+        if (lastCompletedPageIndex === null) {
+            // always is at least the first item...
+            lastCompletedPageIndex = 0;
+        }
+        else if (lastCompletedPageIndex + 1 < allPages.length) {
+            lastCompletedPageIndex = lastCompletedPageIndex + 1;
+        }
+        this.currentPage = allPages[lastCompletedPageIndex];
+    }
+    /**
+     * Finds the first page in the collection of pages and makes that page the
+     * current/active page.
+     *
+     * @memberof WizardNavigationService
+     */
+    setFirstPageCurrent() {
+        this.currentPage = this.pageCollection.pagesAsArray[0];
+    }
+    /**
+     * Updates the stepnav on the left side of the wizard when pages are dynamically
+     * added or removed from the collection of pages.
+     *
+     * @memberof WizardNavigationService
+     */
+    updateNavigation() {
+        let toSetCurrent;
+        this.pageCollection.updateCompletedStates();
+        const currentPageRemoved = this.pageCollection.pagesAsArray.indexOf(this.currentPage) < 0;
+        if (currentPageRemoved) {
+            toSetCurrent = this.pageCollection.findFirstIncompletePage();
+            this.currentPage = toSetCurrent;
+        }
+    }
+}
+WizardNavigationService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: WizardNavigationService, deps: [{ token: i1.PageCollectionService }, { token: i2.ButtonHubService }], target: i0.ɵɵFactoryTarget.Injectable });
+WizardNavigationService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: WizardNavigationService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: WizardNavigationService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i1.PageCollectionService }, { type: i2.ButtonHubService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard-navigation.service.js","sourceRoot":"","sources":["../../../../../projects/angular/src/wizard/providers/wizard-navigation.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright (c) 2016-2021 VMware, Inc. All Rights Reserved.\n * This software is released under MIT license.\n * The full license information can be found in LICENSE in the root directory of this project.\n */\n\nimport { Injectable, OnDestroy, TemplateRef } from '@angular/core';\nimport { Observable } from 'rxjs';\nimport { Subject } from 'rxjs';\nimport { Subscription } from 'rxjs';\n\nimport { ClrWizardPage } from '../wizard-page';\n\nimport { ButtonHubService } from './button-hub.service';\nimport { PageCollectionService } from './page-collection.service';\n\n/**\n * Performs navigation functions for a wizard and manages the current page. Presented as a\n * separate service to encapsulate the behavior of navigating and completing the wizard so\n * that it can be shared across the wizard and its sub-components.\n *\n * The easiest way to access the navigation service is there a reference on your wizard. The\n * Following example would allow you to access your instance of the wizard from your host\n * component and thereby access the navigation service via YourHostComponent.wizard.navService.\n *\n * @example\n * <clr-wizard #wizard ...>\n *\n * @example\n * export class YourHostComponent {\n *   @ViewChild(\"wizard\") wizard: Wizard;\n *   ...\n * }\n *\n */\n@Injectable()\nexport class WizardNavigationService implements OnDestroy {\n  /**\n   * Is notified when a previous button is clicked in the wizard. Performs checks\n   * before alerting the current page of the button click. Enacts navigation to\n   * the previous page if not overridden at the page level.\n   *\n   * @memberof WizardNavigationService\n   */\n  public previousButtonSubscription: Subscription;\n\n  /**\n   * Is notified when a Next button is clicked in the wizard.\n   *\n   * @memberof WizardNavigationService\n   */\n  public nextButtonSubscription: Subscription;\n\n  /**\n   * Is notified when a danger button is clicked in the wizard.\n   *\n   * @memberof WizardNavigationService\n   */\n  public dangerButtonSubscription: Subscription;\n\n  /**\n   * Is notified when a  finish button is clicked in the wizard.\n   *\n   * @memberof WizardNavigationService\n   */\n  public finishButtonSubscription: Subscription;\n\n  /**\n   * Is notified when a Custom button is clicked in the wizard.\n   *\n   * @memberof WizardNavigationService\n   */\n  public customButtonSubscription: Subscription;\n\n  /**\n   * Is notified when a Cancel button is clicked in the wizard. Notifies the wizard,\n   * which handles all cancel functionality, if cancel is not overridden at the page\n   * level.\n   *\n   * @memberof WizardNavigationService\n   */\n  public cancelButtonSubscription: Subscription;\n\n  /**\n   * Resets navigation to make the first page current when the page collection service\n   * emits an event notifying WizardNavigationService that it has reset all pages\n   * to their pristine, incomplete state.\n   *\n   * @memberof WizardNavigationService\n   */\n  public pagesResetSubscription: Subscription;\n\n  /**\n   * Creates an instance of WizardNavigationService. Also sets up subscriptions\n   * that listen to the button service to determine when a button has been clicked\n   * in the wizard. Is also responsible for taking action when the page collection\n   * requests that navigation be reset to its pristine state.\n   *\n   * @memberof WizardNavigationService\n   */\n  constructor(public pageCollection: PageCollectionService, public buttonService: ButtonHubService) {\n    this.previousButtonSubscription = this.buttonService.previousBtnClicked.subscribe(() => {\n      const currentPage = this.currentPage;\n      if (this.currentPageIsFirst || currentPage.previousStepDisabled) {\n        return;\n      }\n      currentPage.previousButtonClicked.emit(currentPage);\n      if (!currentPage.preventDefault) {\n        this.previous();\n      }\n    });\n\n    this.nextButtonSubscription = this.buttonService.nextBtnClicked.subscribe(() => {\n      this.checkAndCommitCurrentPage('next');\n    });\n\n    this.dangerButtonSubscription = this.buttonService.dangerBtnClicked.subscribe(() => {\n      this.checkAndCommitCurrentPage('danger');\n    });\n\n    this.finishButtonSubscription = this.buttonService.finishBtnClicked.subscribe(() => {\n      this.checkAndCommitCurrentPage('finish');\n    });\n\n    this.customButtonSubscription = this.buttonService.customBtnClicked.subscribe((type: string) => {\n      if (!this.wizardStopNavigation) {\n        this.currentPage.customButtonClicked.emit(type);\n      }\n    });\n\n    this.cancelButtonSubscription = this.buttonService.cancelBtnClicked.subscribe(() => {\n      if (this.wizardStopNavigation) {\n        return;\n      }\n\n      if (this.currentPage.preventDefault) {\n        this.currentPage.pageOnCancel.emit(this.currentPage);\n      } else {\n        this.cancel();\n      }\n    });\n\n    this.pagesResetSubscription = this.pageCollection.pagesReset.subscribe(() => {\n      this.setFirstPageCurrent();\n    });\n  }\n\n  /**\n   *\n   * @memberof WizardNavigationService\n   */\n  ngOnDestroy(): void {\n    this.previousButtonSubscription.unsubscribe();\n    this.nextButtonSubscription.unsubscribe();\n    this.dangerButtonSubscription.unsubscribe();\n    this.finishButtonSubscription.unsubscribe();\n    this.customButtonSubscription.unsubscribe();\n    this.cancelButtonSubscription.unsubscribe();\n    this.pagesResetSubscription.unsubscribe();\n  }\n\n  /**\n   *\n   * @memberof WizardNavigationService\n   */\n  private _currentChanged = new Subject<ClrWizardPage>();\n\n  /**\n   * An Observable that is predominantly used amongst the subcomponents and services\n   * of the wizard. It is recommended that users listen to the ClrWizardPage.onLoad\n   * (clrWizardPageOnLoad) output instead of this Observable.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get currentPageChanged(): Observable<ClrWizardPage> {\n    // TODO: MAKE SURE EXTERNAL OUTPUTS SAY 'CHANGE' NOT 'CHANGED'\n    // A BREAKING CHANGE SO AWAITING MINOR RELEASE\n    return this._currentChanged.asObservable();\n  }\n\n  /**\n   * A Boolean flag used by the ClrWizardPage to avoid a race condition when pages are\n   * loading and there is no current page defined.\n   *\n   * @memberof WizardNavigationService\n   */\n  public navServiceLoaded = false;\n\n  /**\n   * A boolean flag shared across the Wizard subcomponents that follows the value\n   * of the Wizard.forceForward (clrWizardForceForwardNavigation) input. When true,\n   * navigating backwards in the stepnav menu will reset any skipped pages' completed\n   * state to false.\n   *\n   * This is useful when a wizard executes validation on a page-by-page basis when\n   * the next button is clicked.\n   *\n   * @memberof WizardNavigationService\n   */\n  public forceForwardNavigation = false;\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  public get currentPageTitle(): TemplateRef<any> {\n    // when the querylist of pages is empty. this is the first place it fails...\n    if (!this.currentPage) {\n      return null;\n    }\n    return this.currentPage.title;\n  }\n\n  /**\n   * Returns a Boolean that tells you whether or not the current page is the first\n   * page in the Wizard.\n   *\n   * This is helpful for determining whether a page is navigable.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get currentPageIsFirst(): boolean {\n    return this.pageCollection.firstPage === this.currentPage;\n  }\n\n  /**\n   * Returns a Boolean that tells you whether or not the current page is the\n   * last page in the Wizard.\n   *\n   * This is used to determine which buttons should display in the wizard footer.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get currentPageIsLast(): boolean {\n    return this.pageCollection.lastPage === this.currentPage;\n  }\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  private _currentPage: ClrWizardPage;\n\n  /**\n   * Returns the ClrWizardPage object of the current page or null.\n   *\n   * @memberof WizardNavigationService\n   */\n  get currentPage(): ClrWizardPage {\n    if (!this._currentPage) {\n      return null;\n    }\n    return this._currentPage;\n  }\n\n  /**\n   * Accepts a ClrWizardPage object, since that object to be the current/active\n   * page in the wizard, and emits the ClrWizardPage.onLoad (clrWizardPageOnLoad)\n   * event for that page.\n   *\n   * Note that all of this work is bypassed if the ClrWizardPage object is already\n   * the current page.\n   *\n   * @memberof WizardNavigationService\n   */\n  set currentPage(page: ClrWizardPage) {\n    if (this._currentPage !== page && !this.wizardStopNavigation) {\n      this._currentPage = page;\n      page.onLoad.emit(page.id);\n      this._currentChanged.next(page);\n    }\n  }\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  private _movedToNextPage = new Subject<boolean>();\n\n  /**\n   * An observable used internally to alert the wizard that forward navigation\n   * has occurred. It is recommended that you use the Wizard.onMoveNext\n   * (clrWizardOnNext) output instead of this one.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get movedToNextPage(): Observable<boolean> {\n    return this._movedToNextPage.asObservable();\n  }\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  private _wizardFinished = new Subject<boolean>();\n\n  /**\n   * An observable used internally to alert the wizard that the nav service\n   * has approved completion of the wizard.\n   *\n   * It is recommended that you use the Wizard.wizardFinished (clrWizardOnFinish)\n   * output instead of this one.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get wizardFinished(): Observable<boolean> {\n    return this._wizardFinished.asObservable();\n  }\n\n  /**\n   * This is a public function that can be used to programmatically advance\n   * the user to the next page.\n   *\n   * When invoked, this method will move the wizard to the next page after\n   * successful validation. Note that this method goes through all checks\n   * and event emissions as if Wizard.next(false) had been called.\n   *\n   * In most cases, it makes more sense to use Wizard.next(false).\n   *\n   * @memberof WizardNavigationService\n   */\n  public next(): void {\n    if (this.currentPageIsLast) {\n      this.checkAndCommitCurrentPage('finish');\n    } else {\n      this.checkAndCommitCurrentPage('next');\n    }\n  }\n\n  /**\n   * Bypasses checks and most event emissions to force a page to navigate forward.\n   *\n   * Comparable to calling Wizard.next() or Wizard.forceNext().\n   *\n   * @memberof WizardNavigationService\n   */\n  public forceNext(): void {\n    const currentPage: ClrWizardPage = this.currentPage;\n    const nextPage: ClrWizardPage = this.pageCollection.getNextPage(currentPage);\n\n    // catch errant null or undefineds that creep in\n    if (!nextPage) {\n      throw new Error('The wizard has no next page to go to.');\n    }\n\n    if (this.wizardStopNavigation) {\n      return;\n    }\n\n    if (!currentPage.completed) {\n      // this is a state that alt next flows can get themselves in...\n      this.pageCollection.commitPage(currentPage);\n    }\n    this.currentPage = nextPage;\n  }\n\n  /**\n   * Accepts a button/action type as a parameter. Encapsulates all logic for\n   * event emissions, state of the current page, and wizard and page level overrides.\n   *\n   * Avoid calling this function directly unless you really know what you're doing.\n   *\n   * @memberof WizardNavigationService\n   */\n  public checkAndCommitCurrentPage(buttonType: string): void {\n    const currentPage: ClrWizardPage = this.currentPage;\n\n    if (!currentPage.readyToComplete || this.wizardStopNavigation) {\n      return;\n    }\n\n    const iAmTheLastPage = this.currentPageIsLast;\n\n    const isNext = buttonType === 'next';\n    const isDanger = buttonType === 'danger';\n    const isDangerNext = isDanger && !iAmTheLastPage;\n    const isDangerFinish = isDanger && iAmTheLastPage;\n    const isFinish = buttonType === 'finish' || isDangerFinish;\n\n    if (isFinish && !iAmTheLastPage) {\n      return;\n    }\n\n    currentPage.primaryButtonClicked.emit(buttonType);\n\n    if (isFinish) {\n      currentPage.finishButtonClicked.emit(currentPage);\n    } else if (isDanger) {\n      currentPage.dangerButtonClicked.emit();\n    } else if (isNext) {\n      currentPage.nextButtonClicked.emit();\n    }\n\n    if (currentPage.stopNext || currentPage.preventDefault) {\n      currentPage.onCommit.emit(currentPage.id);\n      return;\n    }\n\n    // order is very important with these emitters!\n    if (isFinish) {\n      // mark page as complete\n      if (!this.wizardHasAltNext) {\n        this.pageCollection.commitPage(currentPage);\n      }\n      this._wizardFinished.next();\n    }\n\n    if (this.wizardHasAltNext) {\n      this.pageCollection.commitPage(currentPage);\n\n      if (isNext || isDangerNext) {\n        this._movedToNextPage.next(true);\n      }\n      // jump out here, no matter what type we're looking at\n      return;\n    }\n\n    if (isNext || isDangerNext) {\n      this.forceNext();\n    }\n\n    if (!this.wizardHasAltNext && !this.wizardStopNavigation) {\n      this._movedToNextPage.next(true);\n    }\n  }\n\n  /**\n   * This is a public function that can be used to programmatically conclude\n   * the wizard.\n   *\n   * When invoked, this method will  initiate the work involved with finalizing\n   * and finishing the wizard workflow. Note that this method goes through all\n   * checks and event emissions as if Wizard.finish(false) had been called.\n   *\n   * In most cases, it makes more sense to use Wizard.finish(false).\n   *\n   * @memberof WizardNavigationService\n   */\n  public finish(): void {\n    this.checkAndCommitCurrentPage('finish');\n  }\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  private _movedToPreviousPage = new Subject<boolean>();\n\n  /**\n   * Notifies the wizard when backwards navigation has occurred via the\n   * previous button.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get movedToPreviousPage(): Observable<boolean> {\n    return this._movedToPreviousPage.asObservable();\n  }\n\n  /**\n   * Programmatically moves the wizard to the page before the current page.\n   *\n   * In most instances, it makes more sense to call Wizard.previous()\n   * which does the same thing.\n   *\n   * @memberof WizardNavigationService\n   */\n  public previous(): void {\n    if (this.currentPageIsFirst || this.wizardStopNavigation) {\n      return;\n    }\n\n    const previousPage = this.pageCollection.getPreviousPage(this.currentPage);\n\n    if (!previousPage) {\n      return;\n    }\n\n    this._movedToPreviousPage.next(true);\n\n    if (this.forceForwardNavigation) {\n      this.currentPage.completed = false;\n    }\n\n    this.currentPage = previousPage;\n  }\n\n  /**\n   * @memberof WizardNavigationService\n   */\n  private _cancelWizard = new Subject<any>();\n\n  /**\n   * Notifies the wizard that a user is trying to cancel it.\n   *\n   * @memberof WizardNavigationService\n   */\n  public get notifyWizardCancel(): Observable<any> {\n    return this._cancelWizard.asObservable();\n  }\n\n  /**\n   * Allows a hook into the cancel workflow of the wizard from the nav service. Note that\n   * this route goes through all checks and event emissions as if a cancel button had\n   * been clicked.\n   *\n   * In most cases, users looking for a hook into the cancel routine are actually looking\n   * for a way to close the wizard from their host component because they have prevented\n   * the default cancel action.\n   *\n   * In this instance, it is recommended that you use Wizard.close() to avoid any event\n   * emission loop resulting from an event handler calling back into routine that will\n   * again evoke the events it handles.\n   *\n   * @memberof WizardNavigationService\n   */\n  public cancel(): void {\n    this._cancelWizard.next();\n  }\n\n  /**\n   * A boolean flag shared across the Wizard subcomponents that follows the value\n   * of the Wizard.stopCancel (clrWizardPreventDefaultCancel) input. When true, the cancel\n   * routine is subverted and must be reinstated in the host component calling Wizard.close()\n   * at some point.\n   *\n   * @memberof WizardNavigationService\n   */\n  public wizardHasAltCancel = false;\n\n  /**\n   * A boolean flag shared across the Wizard subcomponents that follows the value\n   * of the Wizard.stopNext (clrWizardPreventDefaultNext) input. When true, the next and finish\n   * routines are subverted and must be reinstated in the host component calling Wizard.next(),\n   * Wizard.forceNext(), Wizard.finish(), or Wizard.forceFinish().\n   *\n   * @memberof WizardNavigationService\n   */\n  public wizardHasAltNext = false;\n\n  /**\n   * A boolean flag shared across the Wizard subcomponents that follows the value\n   * of the Wizard.stopNavigation (clrWizardPreventNavigation) input. When true, all\n   * navigational elements in the wizard are disabled.\n   *\n   * This is intended to freeze the wizard in place. Events are not fired so this is\n   * not a way to implement alternate functionality for navigation.\n   *\n   * @memberof WizardNavigationService\n   */\n  public wizardStopNavigation = false;\n\n  /**\n   * A boolean flag shared with the stepnav items that prevents user clicks on\n   * stepnav items from navigating the wizard.\n   *\n   * @memberof WizardNavigationService\n   */\n  public wizardDisableStepnav = false;\n\n  /**\n   * Performs all required checks to determine if a user can navigate to a page. Checking at each\n   * point if a page is navigable -- completed where the page immediately after the last completed\n   * page.\n   *\n   * Takes two parameters. The first one must be either the ClrWizardPage object or the ID of the\n   * ClrWizardPage object that you want to make the current page.\n   *\n   * The second parameter is optional and is a Boolean flag for \"lazy completion\". What this means\n   * is the Wizard will mark all pages between the current page and the page you want to navigate\n   * to as completed. This is useful for informational wizards that do not require user action,\n   * allowing an easy means for users to jump ahead.\n   *\n   * To avoid checks on navigation, use ClrWizardPage.makeCurrent() instead.\n   *\n   * @memberof WizardNavigationService\n   */\n  public goTo(pageToGoToOrId: any, lazyComplete = false) {\n    const myPages = this.pageCollection;\n    const pageToGoTo = typeof pageToGoToOrId === 'string' ? myPages.getPageById(pageToGoToOrId) : pageToGoToOrId;\n    const currentPage = this.currentPage;\n\n    // no point in going to the current page. you're there already!\n    // also hard block on any navigation when stopNavigation is true\n    if (pageToGoTo === currentPage || this.wizardStopNavigation) {\n      return;\n    }\n\n    const currentPageIndex = myPages.getPageIndex(currentPage);\n    const goToPageIndex = myPages.getPageIndex(pageToGoTo);\n    const goingForward = goToPageIndex > currentPageIndex;\n    const pagesToCheck = myPages.getPageRangeFromPages(this.currentPage, pageToGoTo);\n    const okayToMove = lazyComplete || this.canGoTo(pagesToCheck);\n\n    if (!okayToMove) {\n      return;\n    }\n\n    if (goingForward && lazyComplete) {\n      pagesToCheck.forEach((page: ClrWizardPage) => {\n        if (page !== pageToGoTo) {\n          page.completed = true;\n        }\n      });\n    } else if (!goingForward && this.forceForwardNavigation) {\n      pagesToCheck.forEach((page: ClrWizardPage) => {\n        page.completed = false;\n      });\n    }\n\n    this.currentPage = pageToGoTo;\n  }\n\n  /**\n   * Accepts a range of ClrWizardPage objects as a parameter. Performs the work of checking\n   * those objects to determine if navigation can be accomplished.\n   *\n   * @memberof WizardNavigationService\n   */\n  public canGoTo(pagesToCheck: ClrWizardPage[]): boolean {\n    let okayToMove = true;\n    const myPages = this.pageCollection;\n\n    // previous page can be important when moving because if it's completed it\n    // allows us to move to the page even if it's incomplete...\n    let previousPagePasses: boolean;\n\n    if (!pagesToCheck || pagesToCheck.length < 1) {\n      return false;\n    }\n\n    pagesToCheck.forEach((page: ClrWizardPage) => {\n      if (!okayToMove) {\n        return;\n      }\n\n      if (page.completed) {\n        // default is true. just jump out instead of complicating it.\n        return;\n      }\n\n      // so we know our page is not completed...\n      const previousPage = myPages.getPageIndex(page) > 0 ? myPages.getPreviousPage(page) : null;\n      previousPagePasses = previousPage === null || previousPage.completed === true;\n\n      // we are false if not the current page AND previous page is not completed\n      // (but must have a previous page)\n      if (!page.current && !previousPagePasses) {\n        okayToMove = false;\n      }\n      // falls through to true as default\n    });\n\n    return okayToMove;\n  }\n\n  /**\n   * Looks through the collection of pages to find the first one that is incomplete\n   * and makes that page the current/active page.\n   *\n   * @memberof WizardNavigationService\n   */\n  public setLastEnabledPageCurrent(): void {\n    const allPages: ClrWizardPage[] = this.pageCollection.pagesAsArray;\n    let lastCompletedPageIndex: number = null;\n\n    allPages.forEach((page: ClrWizardPage, index: number) => {\n      if (page.completed) {\n        lastCompletedPageIndex = index;\n      }\n    });\n\n    if (lastCompletedPageIndex === null) {\n      // always is at least the first item...\n      lastCompletedPageIndex = 0;\n    } else if (lastCompletedPageIndex + 1 < allPages.length) {\n      lastCompletedPageIndex = lastCompletedPageIndex + 1;\n    }\n\n    this.currentPage = allPages[lastCompletedPageIndex];\n  }\n\n  /**\n   * Finds the first page in the collection of pages and makes that page the\n   * current/active page.\n   *\n   * @memberof WizardNavigationService\n   */\n  public setFirstPageCurrent(): void {\n    this.currentPage = this.pageCollection.pagesAsArray[0];\n  }\n\n  /**\n   * Updates the stepnav on the left side of the wizard when pages are dynamically\n   * added or removed from the collection of pages.\n   *\n   * @memberof WizardNavigationService\n   */\n  public updateNavigation(): void {\n    let toSetCurrent: ClrWizardPage;\n\n    this.pageCollection.updateCompletedStates();\n\n    const currentPageRemoved = this.pageCollection.pagesAsArray.indexOf(this.currentPage) < 0;\n    if (currentPageRemoved) {\n      toSetCurrent = this.pageCollection.findFirstIncompletePage();\n      this.currentPage = toSetCurrent;\n    }\n  }\n}\n"]}