@clr/angular 12.0.7 → 13.0.0-next.1

package/esm2020/wizard/wizard.mjs

@@ -0,0 +1,475 @@
+/*
+ * 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 { Component, ContentChildren, EventEmitter, Input, Output, ViewChild, PLATFORM_ID, Inject, } from '@angular/core';
+import { isPlatformBrowser } from '@angular/common';
+import { filter } from 'rxjs/operators';
+import { ButtonHubService } from './providers/button-hub.service';
+import { HeaderActionService } from './providers/header-actions.service';
+import { PageCollectionService } from './providers/page-collection.service';
+import { WizardNavigationService } from './providers/wizard-navigation.service';
+import { ClrWizardHeaderAction } from './wizard-header-action';
+import { ClrWizardPage } from './wizard-page';
+import * as i0 from "@angular/core";
+import * as i1 from "./providers/wizard-navigation.service";
+import * as i2 from "./providers/page-collection.service";
+import * as i3 from "./providers/button-hub.service";
+import * as i4 from "./providers/header-actions.service";
+import * as i5 from "../modal/modal";
+import * as i6 from "./wizard-stepnav";
+import * as i7 from "@angular/common";
+import * as i8 from "../modal/modal-body";
+export class ClrWizard {
+    constructor(platformId, navService, pageCollection, buttonService, headerActionService, elementRef, differs) {
+        this.platformId = platformId;
+        this.navService = navService;
+        this.pageCollection = pageCollection;
+        this.buttonService = buttonService;
+        this.headerActionService = headerActionService;
+        this.elementRef = elementRef;
+        /**
+         * Set the modal size of the wizard. Set using `[clrWizardSize]` input.
+         */
+        this.size = 'xl';
+        /**
+         * Tells the modal part of the wizard whether it should have a close "X"
+         * in the top right corner. Set using `[clrWizardClosable]` input.
+         */
+        this.closable = true;
+        this._forceForward = false;
+        this._open = false;
+        this._stopNext = false;
+        this._stopCancel = false;
+        this._stopNavigation = false;
+        this._disableStepnav = false;
+        /**
+         * Used to communicate to the underlying modal that animations are not
+         * wanted. Primary use is for the display of static/inline wizards.
+         * Set using `[clrWizardPreventModalAnimation]` input.
+         */
+        /** @deprecated since 3.0, input should be removed in 4.0 because is only related to inline wizards */
+        this._stopModalAnimations = false;
+        /**
+         * Emits when the wizard is opened or closed.
+         * Listen via `(clrWizardOpenChange)` event.
+         */
+        this._openChanged = new EventEmitter(false);
+        /**
+         * Emits when the wizard is canceled. Listen via `(clrWizardOnCancel)` event.
+         * Can be combined with the `[clrWizardPreventDefaultCancel]` input to create
+         * wizard-level custom cancel routines.
+         */
+        this.onCancel = new EventEmitter(false);
+        /**
+         * Emits when the wizard is completed. Listen via `(clrWizardOnFinish)` event.
+         * Can be combined with the `[clrWizardPreventDefaultNext]` input to create
+         * wizard-level custom completion routines.
+         */
+        this.wizardFinished = new EventEmitter(false);
+        /**
+         * Emits when the wizard is reset. Listen via `(clrWizardOnReset)` event.
+         */
+        this.onReset = new EventEmitter(false);
+        /**
+         * Emits when the current page has changed. Listen via `(clrWizardCurrentPageChanged)` event.
+         * output. Useful for non-blocking validation.
+         */
+        this.currentPageChanged = new EventEmitter(false);
+        /**
+         * Emits when the wizard moves to the next page. Listen via `(clrWizardOnNext)` event.
+         * Can be combined with the `[clrWizardPreventDefaultNext]` input to create
+         * wizard-level custom navigation routines, which are useful for validation.
+         */
+        this.onMoveNext = new EventEmitter(false);
+        /**
+         * Emits when the wizard moves to the previous page. Can be useful for validation.
+         * Listen via `(clrWizardOnPrevious)` event.
+         */
+        this.onMovePrevious = new EventEmitter(false);
+        this.subscriptions = [];
+        this.subscriptions.push(this.listenForNextPageChanges(), this.listenForPreviousPageChanges(), this.listenForCancelChanges(), this.listenForFinishedChanges(), this.listenForPageChanges());
+        this.differ = differs.find([]).create(null);
+    }
+    /**
+     * Resets page completed states when navigating backwards.
+     * Set using `[clrWizardForceForwardNavigation]` input.
+     */
+    set forceForward(value) {
+        this._forceForward = !!value;
+        this.navService.forceForwardNavigation = value;
+    }
+    get forceForward() {
+        return this._forceForward;
+    }
+    /**
+     * Toggles open/close of the wizard component.
+     * Set using the `[clrWizardOpen]` input.
+     */
+    set clrWizardOpen(open) {
+        if (open) {
+            this.buttonService.buttonsReady = true;
+        }
+        this._open = open;
+    }
+    /**
+     * Prevents ClrWizard from moving to the next page or closing itself on finishing.
+     * Set using the `[clrWizardPreventDefaultNext]` input. Note that using stopNext
+     * will require you to create your own calls to .next() and .finish() in your
+     * host component to make the ClrWizard work as expected.
+     */
+    set stopNext(value) {
+        this._stopNext = !!value;
+        this.navService.wizardHasAltNext = value;
+    }
+    get stopNext() {
+        return this._stopNext;
+    }
+    /**
+     * Prevents ClrWizard from closing when the cancel button or close "X" is clicked.
+     * Set using the `[clrWizardPreventDefaultCancel]` input.
+     *
+     * Note that using stopCancel will require you to create your own calls to `close()` in your host compone`nt
+     * to make the ClrWizard work as expected. Useful for doing checks or prompts
+     * before closing a ClrWizard.
+     */
+    set stopCancel(value) {
+        this._stopCancel = !!value;
+        this.navService.wizardHasAltCancel = value;
+    }
+    get stopCancel() {
+        return this._stopCancel;
+    }
+    /**
+     * Prevents ClrWizard from performing any form of navigation away from the current
+     * page. Set using the `[clrWizardPreventNavigation]` input.
+     * Note that stopNavigation is meant to freeze the wizard in place, typically
+     * during a long validation or background action where you want the wizard to
+     * display loading content but not allow the user to execute navigation in
+     * the stepnav, close X, or the  back, finish, or next buttons.
+     */
+    set stopNavigation(value) {
+        this._stopNavigation = !!value;
+        this.navService.wizardStopNavigation = value;
+    }
+    get stopNavigation() {
+        return this._stopNavigation;
+    }
+    /**
+     * Prevents clicks on the links in the stepnav from working.
+     * Set using `[clrWizardDisableStepnav]` input.
+     * A more granular bypassing of navigation which can be useful when your
+     * ClrWizard is in a state of completion and you don't want users to be
+     * able to jump backwards and change things.
+     */
+    set disableStepnav(value) {
+        this._disableStepnav = !!value;
+        this.navService.wizardDisableStepnav = value;
+    }
+    get disableStepnav() {
+        return this._disableStepnav;
+    }
+    get stopModalAnimations() {
+        return this._stopModalAnimations ? 'true' : 'false';
+    }
+    get currentPage() {
+        return this.navService.currentPage;
+    }
+    set currentPage(page) {
+        this.navService.goTo(page, true);
+    }
+    get isLast() {
+        return this.navService.currentPageIsLast;
+    }
+    get isFirst() {
+        return this.navService.currentPageIsFirst;
+    }
+    get isStatic() {
+        return this.elementRef.nativeElement.classList.contains('clr-wizard--inline');
+    }
+    ngAfterContentInit() {
+        this.pageCollection.pages = this.pages;
+        this.headerActionService.wizardHeaderActions = this.headerActions;
+        this.initializeButtons();
+    }
+    ngDoCheck() {
+        this.updateNavOnPageChanges();
+    }
+    ngOnDestroy() {
+        this.subscriptions.forEach(s => s.unsubscribe());
+    }
+    /**
+     * Marks Wizard as finished. By default it does not execute event
+     * emissions or checks before completing and closing. This method is commonly
+     * used as part of an alternative navigation with `[clrWizardPreventDefaultNext]`.
+     *
+     * If `skipChecksAndEmits` is true, the wizard will complete and close
+     * regardless of the state of its current page. This is useful for alternative
+     * navigation where event emissions have already been done and firing them again
+     * may cause an event loop.
+     */
+    finish(skipChecksAndEmits = true) {
+        if (skipChecksAndEmits) {
+            this.forceFinish();
+        }
+        else {
+            this.navService.finish();
+        }
+    }
+    /**
+     * Marks the wizard as finished but does run checks and emissions.
+     * Good for a last step in an alternate workflow. Does the same thing as
+     * calling `ClrWizard.finish(true)` or `ClrWizard.finish()` without a parameter.
+     */
+    forceFinish() {
+        if (this.stopNavigation) {
+            return;
+        }
+        this.close();
+    }
+    /**
+     * Opens the wizard. If there is no current page defined, sets the first page in the wizard to be current.
+     */
+    open() {
+        this._open = true;
+        if (!this.currentPage) {
+            this.navService.setFirstPageCurrent();
+        }
+        // Only render buttons when wizard is opened, to avoid chocolate errors
+        this.buttonService.buttonsReady = true;
+        this._openChanged.emit(true);
+    }
+    /**
+     * Closes the wizard. Call this directly instead of `cancel()` to implement alternative cancel functionality.
+     */
+    close() {
+        if (this.stopNavigation) {
+            return;
+        }
+        this._open = false;
+        this._openChanged.emit(false);
+    }
+    /**
+     * Used to open and close the wizard. By default the wizard will
+     * close if invoked with no parameter. If parameter is true wizard will open
+     * else if false will close.
+     */
+    toggle(open) {
+        if (open) {
+            this.open();
+        }
+        else {
+            this.close();
+        }
+    }
+    /**
+     * Moves the wizard to the previous page.
+     */
+    previous() {
+        this.navService.previous();
+    }
+    /**
+     * By default, `next()` does not execute event emissions.
+     * This method is commonly called as part of an alternative navigation
+     * with `[clrWizardPreventDefaultNext]`. The wizard will move to the next page
+     * regardless of the state of its current page. This is useful for alternative
+     * navigation where event emissions have already been done and firing them again
+     * may cause an event loop.
+     *
+     * If `skipChecksAndEmits` is false, the wizard will execute default checks
+     * and emit events as normal. This is useful for custom buttons or programmatic
+     * workflows that are not executing the wizards default checks and emissions.
+     * It is another way to navigate without having to rewrite the wizard’s default
+     * functionality from scratch.
+     */
+    next(skipChecksAndEmits = true) {
+        if (skipChecksAndEmits) {
+            this.forceNext();
+        }
+        else {
+            this.navService.next();
+        }
+    }
+    /**
+     * Moves the wizard to the next page without the checks and emissions.
+     * Good for a last step in an alternate workflow.
+     * Alias for `ClrWizard.next(true)` or `ClrWizard.next()`
+     */
+    forceNext() {
+        this.navService.forceNext();
+    }
+    /**
+     * Cancels and closes the wizard. Do not use this for an override of the cancel
+     * the functionality with `[clrWizardPreventDefaultCancel]`, `[clrWizardPreventPageDefaultCancel]`,
+     * or `[clrWizardPagePreventDefault]` because it will initiate the same checks
+     * and event emissions that invoked your event handler. Use `ClrWizard.close()` instead.
+     */
+    cancel() {
+        this.navService.cancel();
+    }
+    /**
+     * Overrides behavior of the underlying modal to avoid collisions with
+     * alternative cancel functionality. In most cases, use `ClrWizard.cancel()` instead.
+     */
+    modalCancel() {
+        if (this.closable) {
+            this.checkAndCancel();
+        }
+    }
+    /**
+     * Checks for alternative cancel flows defined at the current page or
+     * wizard level. Performs a canceled if not. Emits events that initiate
+     * the alternative cancel outputs `(clrWizardPageOnCancel)` and `(clrWizardOnCancel)`.
+     */
+    checkAndCancel() {
+        const currentPage = this.currentPage;
+        const currentPageHasOverrides = currentPage.stopCancel || currentPage.preventDefault;
+        if (this.stopNavigation) {
+            return;
+        }
+        currentPage.pageOnCancel.emit();
+        if (!currentPageHasOverrides) {
+            this.onCancel.emit();
+        }
+        if (!this.stopCancel && !currentPageHasOverrides) {
+            this.close();
+        }
+    }
+    /**
+     * Navigates to a given page in the Wizard. Navigation will invoke the wizard’s default
+     * checks and event emissions.
+     *
+     * The format of the expected ID parameter can be found in the return of the
+     * ClrWizardPage.id getter, usually prefixed with `clr-wizard-page-` and then either a
+     * numeric ID or the ID specified for the `ClrWizardPage` component’s `id` input.
+     */
+    goTo(pageId) {
+        if (!pageId) {
+            return;
+        }
+        this.navService.goTo(pageId);
+    }
+    /**
+     * Reset sets all WizardPages to incomplete and sets the first page in the `ClrWizard` to
+     * be the current page, resetting the wizard navigation.
+     * Use `(clrWizardOnReset)` event to reset the data or model of your wizard.
+     */
+    reset() {
+        this.pageCollection.reset();
+        this.onReset.next();
+    }
+    listenForNextPageChanges() {
+        return this.navService.movedToNextPage.pipe(filter(() => isPlatformBrowser(this.platformId))).subscribe(() => {
+            this.onMoveNext.emit();
+            this.wizardTitle.nativeElement.focus();
+        });
+    }
+    listenForPreviousPageChanges() {
+        return this.navService.movedToPreviousPage.pipe(filter(() => isPlatformBrowser(this.platformId))).subscribe(() => {
+            this.onMovePrevious.emit();
+            this.wizardTitle.nativeElement.focus();
+        });
+    }
+    listenForCancelChanges() {
+        return this.navService.notifyWizardCancel.subscribe(() => this.checkAndCancel());
+    }
+    listenForFinishedChanges() {
+        return this.navService.wizardFinished.subscribe(() => this.emitWizardFinished());
+    }
+    listenForPageChanges() {
+        return this.navService.currentPageChanged.subscribe(() => this.currentPageChanged.emit());
+    }
+    updateNavOnPageChanges() {
+        const changes = this.differ.diff(this.pages);
+        if (changes) {
+            changes.forEachAddedItem(() => this.navService.updateNavigation());
+            changes.forEachRemovedItem(() => this.navService.updateNavigation());
+        }
+    }
+    initializeButtons() {
+        // Only trigger buttons ready if default is open (inlined)
+        if (this._open) {
+            this.buttonService.buttonsReady = true;
+        }
+    }
+    emitWizardFinished() {
+        if (!this.stopNext) {
+            this.forceFinish();
+        }
+        this.wizardFinished.emit();
+    }
+}
+ClrWizard.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizard, deps: [{ token: PLATFORM_ID }, { token: i1.WizardNavigationService }, { token: i2.PageCollectionService }, { token: i3.ButtonHubService }, { token: i4.HeaderActionService }, { token: i0.ElementRef }, { token: i0.IterableDiffers }], target: i0.ɵɵFactoryTarget.Component });
+ClrWizard.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.0.0", type: ClrWizard, selector: "clr-wizard", inputs: { size: ["clrWizardSize", "size"], closable: ["clrWizardClosable", "closable"], forceForward: ["clrWizardForceForwardNavigation", "forceForward"], clrWizardOpen: "clrWizardOpen", stopNext: ["clrWizardPreventDefaultNext", "stopNext"], stopCancel: ["clrWizardPreventDefaultCancel", "stopCancel"], stopNavigation: ["clrWizardPreventNavigation", "stopNavigation"], disableStepnav: ["clrWizardDisableStepnav", "disableStepnav"], _stopModalAnimations: ["clrWizardPreventModalAnimation", "_stopModalAnimations"] }, outputs: { _openChanged: "clrWizardOpenChange", onCancel: "clrWizardOnCancel", wizardFinished: "clrWizardOnFinish", onReset: "clrWizardOnReset", currentPageChanged: "clrWizardCurrentPageChanged", onMoveNext: "clrWizardOnNext", onMovePrevious: "clrWizardOnPrevious" }, host: { properties: { "class.clr-wizard": "true", "class.wizard-md": "size == 'md'", "class.wizard-lg": "size == 'lg'", "class.wizard-xl": "size == 'xl'", "class.lastPage": "navService.currentPageIsLast" } }, providers: [WizardNavigationService, PageCollectionService, ButtonHubService, HeaderActionService], queries: [{ propertyName: "pages", predicate: ClrWizardPage, descendants: true }, { propertyName: "headerActions", predicate: ClrWizardHeaderAction }], viewQueries: [{ propertyName: "wizardTitle", first: true, predicate: ["wizardTitle"], descendants: true }], ngImport: i0, template: "<!--\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\n<clr-modal\n  [clrModalOpen]=\"_open\"\n  [clrModalSize]=\"size\"\n  [clrModalClosable]=\"closable\"\n  [clrModalStaticBackdrop]=\"true\"\n  [clrModalSkipAnimation]=\"stopModalAnimations\"\n  [clrModalOverrideScrollService]=\"isStatic\"\n  [clrModalPreventClose]=\"true\"\n  (clrModalAlternateClose)=\"modalCancel()\"\n>\n  <nav class=\"modal-nav clr-wizard-stepnav-wrapper\">\n    <h1 class=\"clr-wizard-title\"><ng-content select=\"clr-wizard-title\"></ng-content></h1>\n    <clr-wizard-stepnav></clr-wizard-stepnav>\n  </nav>\n\n  <h2 class=\"modal-title\">\n    <span tabindex=\"-1\" #wizardTitle class=\"modal-title-text\">\n      <ng-template [ngTemplateOutlet]=\"navService.currentPageTitle\"></ng-template>\n    </span>\n\n    <div class=\"modal-header-actions-wrapper\" *ngIf=\"headerActionService.displayHeaderActionsWrapper\">\n      <div *ngIf=\"headerActionService.showWizardHeaderActions\">\n        <ng-content select=\"clr-wizard-header-action\"></ng-content>\n      </div>\n      <div *ngIf=\"headerActionService.currentPageHasHeaderActions\">\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.headerActions\"></ng-template>\n      </div>\n    </div>\n  </h2>\n\n  <div class=\"modal-body\">\n    <main clr-wizard-pages-wrapper class=\"clr-wizard-content\">\n      <ng-content></ng-content>\n    </main>\n  </div>\n  <div class=\"modal-footer clr-wizard-footer\">\n    <div class=\"clr-wizard-footer-buttons\">\n      <div\n        *ngIf=\"navService.currentPage && !navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-content select=\"clr-wizard-button\"></ng-content>\n      </div>\n      <div\n        *ngIf=\"navService.currentPage && navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.buttons\"></ng-template>\n      </div>\n    </div>\n  </div>\n</clr-modal>\n", components: [{ type: i5.ClrModal, selector: "clr-modal", inputs: ["clrModalOpen", "clrModalClosable", "clrModalSize", "clrModalStaticBackdrop", "clrModalSkipAnimation", "clrModalOverrideScrollService", "clrModalPreventClose"], outputs: ["clrModalOpenChange", "clrModalAlternateClose"] }, { type: i6.ClrWizardStepnav, selector: "clr-wizard-stepnav" }], directives: [{ type: i7.NgTemplateOutlet, selector: "[ngTemplateOutlet]", inputs: ["ngTemplateOutletContext", "ngTemplateOutlet"] }, { type: i7.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i8.ClrModalBody, selector: ".modal-body" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizard, decorators: [{
+            type: Component,
+            args: [{ selector: 'clr-wizard', providers: [WizardNavigationService, PageCollectionService, ButtonHubService, HeaderActionService], host: {
+                        '[class.clr-wizard]': 'true',
+                        '[class.wizard-md]': "size == 'md'",
+                        '[class.wizard-lg]': "size == 'lg'",
+                        '[class.wizard-xl]': "size == 'xl'",
+                        '[class.lastPage]': 'navService.currentPageIsLast',
+                    }, template: "<!--\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\n<clr-modal\n  [clrModalOpen]=\"_open\"\n  [clrModalSize]=\"size\"\n  [clrModalClosable]=\"closable\"\n  [clrModalStaticBackdrop]=\"true\"\n  [clrModalSkipAnimation]=\"stopModalAnimations\"\n  [clrModalOverrideScrollService]=\"isStatic\"\n  [clrModalPreventClose]=\"true\"\n  (clrModalAlternateClose)=\"modalCancel()\"\n>\n  <nav class=\"modal-nav clr-wizard-stepnav-wrapper\">\n    <h1 class=\"clr-wizard-title\"><ng-content select=\"clr-wizard-title\"></ng-content></h1>\n    <clr-wizard-stepnav></clr-wizard-stepnav>\n  </nav>\n\n  <h2 class=\"modal-title\">\n    <span tabindex=\"-1\" #wizardTitle class=\"modal-title-text\">\n      <ng-template [ngTemplateOutlet]=\"navService.currentPageTitle\"></ng-template>\n    </span>\n\n    <div class=\"modal-header-actions-wrapper\" *ngIf=\"headerActionService.displayHeaderActionsWrapper\">\n      <div *ngIf=\"headerActionService.showWizardHeaderActions\">\n        <ng-content select=\"clr-wizard-header-action\"></ng-content>\n      </div>\n      <div *ngIf=\"headerActionService.currentPageHasHeaderActions\">\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.headerActions\"></ng-template>\n      </div>\n    </div>\n  </h2>\n\n  <div class=\"modal-body\">\n    <main clr-wizard-pages-wrapper class=\"clr-wizard-content\">\n      <ng-content></ng-content>\n    </main>\n  </div>\n  <div class=\"modal-footer clr-wizard-footer\">\n    <div class=\"clr-wizard-footer-buttons\">\n      <div\n        *ngIf=\"navService.currentPage && !navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-content select=\"clr-wizard-button\"></ng-content>\n      </div>\n      <div\n        *ngIf=\"navService.currentPage && navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.buttons\"></ng-template>\n      </div>\n    </div>\n  </div>\n</clr-modal>\n" }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }, { type: i1.WizardNavigationService }, { type: i2.PageCollectionService }, { type: i3.ButtonHubService }, { type: i4.HeaderActionService }, { type: i0.ElementRef }, { type: i0.IterableDiffers }]; }, propDecorators: { size: [{
+                type: Input,
+                args: ['clrWizardSize']
+            }], closable: [{
+                type: Input,
+                args: ['clrWizardClosable']
+            }], forceForward: [{
+                type: Input,
+                args: ['clrWizardForceForwardNavigation']
+            }], clrWizardOpen: [{
+                type: Input,
+                args: ['clrWizardOpen']
+            }], stopNext: [{
+                type: Input,
+                args: ['clrWizardPreventDefaultNext']
+            }], stopCancel: [{
+                type: Input,
+                args: ['clrWizardPreventDefaultCancel']
+            }], stopNavigation: [{
+                type: Input,
+                args: ['clrWizardPreventNavigation']
+            }], disableStepnav: [{
+                type: Input,
+                args: ['clrWizardDisableStepnav']
+            }], _stopModalAnimations: [{
+                type: Input,
+                args: ['clrWizardPreventModalAnimation']
+            }], _openChanged: [{
+                type: Output,
+                args: ['clrWizardOpenChange']
+            }], onCancel: [{
+                type: Output,
+                args: ['clrWizardOnCancel']
+            }], wizardFinished: [{
+                type: Output,
+                args: ['clrWizardOnFinish']
+            }], onReset: [{
+                type: Output,
+                args: ['clrWizardOnReset']
+            }], currentPageChanged: [{
+                type: Output,
+                args: ['clrWizardCurrentPageChanged']
+            }], onMoveNext: [{
+                type: Output,
+                args: ['clrWizardOnNext']
+            }], onMovePrevious: [{
+                type: Output,
+                args: ['clrWizardOnPrevious']
+            }], pages: [{
+                type: ContentChildren,
+                args: [ClrWizardPage, { descendants: true }]
+            }], headerActions: [{
+                type: ContentChildren,
+                args: [ClrWizardHeaderAction]
+            }], wizardTitle: [{
+                type: ViewChild,
+                args: ['wizardTitle']
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"wizard.js","sourceRoot":"","sources":["../../../../projects/angular/src/wizard/wizard.ts","../../../../projects/angular/src/wizard/wizard.html"],"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 {\n  AfterContentInit,\n  Component,\n  ContentChildren,\n  DoCheck,\n  ElementRef,\n  EventEmitter,\n  Input,\n  IterableDiffers,\n  OnDestroy,\n  Output,\n  QueryList,\n  ViewChild,\n  PLATFORM_ID,\n  Inject,\n} from '@angular/core';\nimport { isPlatformBrowser } from '@angular/common';\nimport { Subscription } from 'rxjs';\nimport { filter } from 'rxjs/operators';\n\nimport { ButtonHubService } from './providers/button-hub.service';\nimport { HeaderActionService } from './providers/header-actions.service';\nimport { PageCollectionService } from './providers/page-collection.service';\nimport { WizardNavigationService } from './providers/wizard-navigation.service';\nimport { ClrWizardHeaderAction } from './wizard-header-action';\nimport { ClrWizardPage } from './wizard-page';\n\n@Component({\n  selector: 'clr-wizard',\n  providers: [WizardNavigationService, PageCollectionService, ButtonHubService, HeaderActionService],\n  templateUrl: './wizard.html',\n  host: {\n    '[class.clr-wizard]': 'true',\n    '[class.wizard-md]': \"size == 'md'\",\n    '[class.wizard-lg]': \"size == 'lg'\",\n    '[class.wizard-xl]': \"size == 'xl'\",\n    '[class.lastPage]': 'navService.currentPageIsLast',\n  },\n})\nexport class ClrWizard implements OnDestroy, AfterContentInit, DoCheck {\n  /**\n   * Set the modal size of the wizard. Set using `[clrWizardSize]` input.\n   */\n  @Input('clrWizardSize') size = 'xl';\n\n  /**\n   * Tells the modal part of the wizard whether it should have a close \"X\"\n   * in the top right corner. Set using `[clrWizardClosable]` input.\n   */\n  @Input('clrWizardClosable') closable = true;\n\n  /**\n   * Resets page completed states when navigating backwards.\n   * Set using `[clrWizardForceForwardNavigation]` input.\n   */\n  @Input('clrWizardForceForwardNavigation')\n  set forceForward(value: boolean) {\n    this._forceForward = !!value;\n    this.navService.forceForwardNavigation = value;\n  }\n  get forceForward(): boolean {\n    return this._forceForward;\n  }\n  private _forceForward = false;\n\n  _open = false;\n  /**\n   * Toggles open/close of the wizard component.\n   * Set using the `[clrWizardOpen]` input.\n   */\n  @Input('clrWizardOpen')\n  set clrWizardOpen(open: boolean) {\n    if (open) {\n      this.buttonService.buttonsReady = true;\n    }\n    this._open = open;\n  }\n\n  /**\n   * Prevents ClrWizard from moving to the next page or closing itself on finishing.\n   * Set using the `[clrWizardPreventDefaultNext]` input. Note that using stopNext\n   * will require you to create your own calls to .next() and .finish() in your\n   * host component to make the ClrWizard work as expected.\n   */\n  @Input('clrWizardPreventDefaultNext')\n  set stopNext(value: boolean) {\n    this._stopNext = !!value;\n    this.navService.wizardHasAltNext = value;\n  }\n  get stopNext(): boolean {\n    return this._stopNext;\n  }\n  private _stopNext = false;\n\n  /**\n   * Prevents ClrWizard from closing when the cancel button or close \"X\" is clicked.\n   * Set using the `[clrWizardPreventDefaultCancel]` input.\n   *\n   * Note that using stopCancel will require you to create your own calls to `close()` in your host compone`nt\n   * to make the ClrWizard work as expected. Useful for doing checks or prompts\n   * before closing a ClrWizard.\n   */\n  @Input('clrWizardPreventDefaultCancel')\n  set stopCancel(value: boolean) {\n    this._stopCancel = !!value;\n    this.navService.wizardHasAltCancel = value;\n  }\n  get stopCancel(): boolean {\n    return this._stopCancel;\n  }\n  private _stopCancel = false;\n\n  /**\n   * Prevents ClrWizard from performing any form of navigation away from the current\n   * page. Set using the `[clrWizardPreventNavigation]` input.\n   * Note that stopNavigation is meant to freeze the wizard in place, typically\n   * during a long validation or background action where you want the wizard to\n   * display loading content but not allow the user to execute navigation in\n   * the stepnav, close X, or the  back, finish, or next buttons.\n   */\n  @Input('clrWizardPreventNavigation')\n  set stopNavigation(value: boolean) {\n    this._stopNavigation = !!value;\n    this.navService.wizardStopNavigation = value;\n  }\n  get stopNavigation(): boolean {\n    return this._stopNavigation;\n  }\n  private _stopNavigation = false;\n\n  /**\n   * Prevents clicks on the links in the stepnav from working.\n   * Set using `[clrWizardDisableStepnav]` input.\n   * A more granular bypassing of navigation which can be useful when your\n   * ClrWizard is in a state of completion and you don't want users to be\n   * able to jump backwards and change things.\n   */\n  @Input('clrWizardDisableStepnav')\n  set disableStepnav(value: boolean) {\n    this._disableStepnav = !!value;\n    this.navService.wizardDisableStepnav = value;\n  }\n  get disableStepnav(): boolean {\n    return this._disableStepnav;\n  }\n  private _disableStepnav = false;\n\n  /**\n   * Used to communicate to the underlying modal that animations are not\n   * wanted. Primary use is for the display of static/inline wizards.\n   * Set using `[clrWizardPreventModalAnimation]` input.\n   */\n  /** @deprecated since 3.0, input should be removed in 4.0 because is only related to inline wizards */\n  @Input('clrWizardPreventModalAnimation') _stopModalAnimations = false;\n  get stopModalAnimations(): string {\n    return this._stopModalAnimations ? 'true' : 'false';\n  }\n\n  /**\n   * Emits when the wizard is opened or closed.\n   * Listen via `(clrWizardOpenChange)` event.\n   */\n  @Output('clrWizardOpenChange') _openChanged: EventEmitter<boolean> = new EventEmitter<boolean>(false);\n\n  /**\n   * Emits when the wizard is canceled. Listen via `(clrWizardOnCancel)` event.\n   * Can be combined with the `[clrWizardPreventDefaultCancel]` input to create\n   * wizard-level custom cancel routines.\n   */\n  @Output('clrWizardOnCancel') onCancel: EventEmitter<any> = new EventEmitter<any>(false);\n\n  /**\n   * Emits when the wizard is completed. Listen via `(clrWizardOnFinish)` event.\n   * Can be combined with the `[clrWizardPreventDefaultNext]` input to create\n   * wizard-level custom completion routines.\n   */\n  @Output('clrWizardOnFinish') wizardFinished: EventEmitter<any> = new EventEmitter<any>(false);\n\n  /**\n   * Emits when the wizard is reset. Listen via `(clrWizardOnReset)` event.\n   */\n  @Output('clrWizardOnReset') onReset: EventEmitter<any> = new EventEmitter<any>(false);\n\n  /**\n   * Emits when the current page has changed. Listen via `(clrWizardCurrentPageChanged)` event.\n   * output. Useful for non-blocking validation.\n   */\n  @Output('clrWizardCurrentPageChanged') currentPageChanged: EventEmitter<any> = new EventEmitter<any>(false);\n\n  /**\n   * Emits when the wizard moves to the next page. Listen via `(clrWizardOnNext)` event.\n   * Can be combined with the `[clrWizardPreventDefaultNext]` input to create\n   * wizard-level custom navigation routines, which are useful for validation.\n   */\n  @Output('clrWizardOnNext') onMoveNext: EventEmitter<any> = new EventEmitter<any>(false);\n\n  /**\n   * Emits when the wizard moves to the previous page. Can be useful for validation.\n   * Listen via `(clrWizardOnPrevious)` event.\n   */\n\n  @Output('clrWizardOnPrevious') onMovePrevious: EventEmitter<any> = new EventEmitter<any>(false);\n\n  @ContentChildren(ClrWizardPage, { descendants: true })\n  pages: QueryList<ClrWizardPage>;\n  @ContentChildren(ClrWizardHeaderAction) headerActions: QueryList<ClrWizardHeaderAction>;\n  @ViewChild('wizardTitle') wizardTitle: ElementRef;\n\n  public get currentPage(): ClrWizardPage {\n    return this.navService.currentPage;\n  }\n\n  public set currentPage(page: ClrWizardPage) {\n    this.navService.goTo(page, true);\n  }\n\n  public get isLast(): boolean {\n    return this.navService.currentPageIsLast;\n  }\n\n  public get isFirst(): boolean {\n    return this.navService.currentPageIsFirst;\n  }\n\n  public get isStatic(): boolean {\n    return (this.elementRef.nativeElement as HTMLElement).classList.contains('clr-wizard--inline');\n  }\n\n  private differ: any; // for marking when the collection of wizard pages has been added to or deleted from\n  private subscriptions: Subscription[] = [];\n\n  constructor(\n    @Inject(PLATFORM_ID) private platformId: any,\n    public navService: WizardNavigationService,\n    public pageCollection: PageCollectionService,\n    public buttonService: ButtonHubService,\n    public headerActionService: HeaderActionService,\n    private elementRef: ElementRef,\n    differs: IterableDiffers\n  ) {\n    this.subscriptions.push(\n      this.listenForNextPageChanges(),\n      this.listenForPreviousPageChanges(),\n      this.listenForCancelChanges(),\n      this.listenForFinishedChanges(),\n      this.listenForPageChanges()\n    );\n\n    this.differ = differs.find([]).create(null);\n  }\n\n  public ngAfterContentInit(): void {\n    this.pageCollection.pages = this.pages;\n    this.headerActionService.wizardHeaderActions = this.headerActions;\n    this.initializeButtons();\n  }\n\n  public ngDoCheck(): void {\n    this.updateNavOnPageChanges();\n  }\n\n  public ngOnDestroy(): void {\n    this.subscriptions.forEach(s => s.unsubscribe());\n  }\n\n  /**\n   * Marks Wizard as finished. By default it does not execute event\n   * emissions or checks before completing and closing. This method is commonly\n   * used as part of an alternative navigation with `[clrWizardPreventDefaultNext]`.\n   *\n   * If `skipChecksAndEmits` is true, the wizard will complete and close\n   * regardless of the state of its current page. This is useful for alternative\n   * navigation where event emissions have already been done and firing them again\n   * may cause an event loop.\n   */\n  public finish(skipChecksAndEmits = true): void {\n    if (skipChecksAndEmits) {\n      this.forceFinish();\n    } else {\n      this.navService.finish();\n    }\n  }\n\n  /**\n   * Marks the wizard as finished but does run checks and emissions.\n   * Good for a last step in an alternate workflow. Does the same thing as\n   * calling `ClrWizard.finish(true)` or `ClrWizard.finish()` without a parameter.\n   */\n  public forceFinish(): void {\n    if (this.stopNavigation) {\n      return;\n    }\n\n    this.close();\n  }\n\n  /**\n   * Opens the wizard. If there is no current page defined, sets the first page in the wizard to be current.\n   */\n  public open(): void {\n    this._open = true;\n\n    if (!this.currentPage) {\n      this.navService.setFirstPageCurrent();\n    }\n\n    // Only render buttons when wizard is opened, to avoid chocolate errors\n    this.buttonService.buttonsReady = true;\n\n    this._openChanged.emit(true);\n  }\n\n  /**\n   * Closes the wizard. Call this directly instead of `cancel()` to implement alternative cancel functionality.\n   */\n  public close(): void {\n    if (this.stopNavigation) {\n      return;\n    }\n\n    this._open = false;\n    this._openChanged.emit(false);\n  }\n\n  /**\n   * Used to open and close the wizard. By default the wizard will\n   * close if invoked with no parameter. If parameter is true wizard will open\n   * else if false will close.\n   */\n  public toggle(open: boolean): void {\n    if (open) {\n      this.open();\n    } else {\n      this.close();\n    }\n  }\n\n  /**\n   * Moves the wizard to the previous page.\n   */\n  public previous(): void {\n    this.navService.previous();\n  }\n\n  /**\n   * By default, `next()` does not execute event emissions.\n   * This method is commonly called as part of an alternative navigation\n   * with `[clrWizardPreventDefaultNext]`. The wizard will move to the next page\n   * regardless of the state of its current page. This is useful for alternative\n   * navigation where event emissions have already been done and firing them again\n   * may cause an event loop.\n   *\n   * If `skipChecksAndEmits` is false, the wizard will execute default checks\n   * and emit events as normal. This is useful for custom buttons or programmatic\n   * workflows that are not executing the wizards default checks and emissions.\n   * It is another way to navigate without having to rewrite the wizard’s default\n   * functionality from scratch.\n   */\n  public next(skipChecksAndEmits = true): void {\n    if (skipChecksAndEmits) {\n      this.forceNext();\n    } else {\n      this.navService.next();\n    }\n  }\n\n  /**\n   * Moves the wizard to the next page without the checks and emissions.\n   * Good for a last step in an alternate workflow.\n   * Alias for `ClrWizard.next(true)` or `ClrWizard.next()`\n   */\n  public forceNext(): void {\n    this.navService.forceNext();\n  }\n\n  /**\n   * Cancels and closes the wizard. Do not use this for an override of the cancel\n   * the functionality with `[clrWizardPreventDefaultCancel]`, `[clrWizardPreventPageDefaultCancel]`,\n   * or `[clrWizardPagePreventDefault]` because it will initiate the same checks\n   * and event emissions that invoked your event handler. Use `ClrWizard.close()` instead.\n   */\n  public cancel(): void {\n    this.navService.cancel();\n  }\n\n  /**\n   * Overrides behavior of the underlying modal to avoid collisions with\n   * alternative cancel functionality. In most cases, use `ClrWizard.cancel()` instead.\n   */\n  public modalCancel(): void {\n    if (this.closable) {\n      this.checkAndCancel();\n    }\n  }\n\n  /**\n   * Checks for alternative cancel flows defined at the current page or\n   * wizard level. Performs a canceled if not. Emits events that initiate\n   * the alternative cancel outputs `(clrWizardPageOnCancel)` and `(clrWizardOnCancel)`.\n   */\n  public checkAndCancel(): void {\n    const currentPage = this.currentPage;\n    const currentPageHasOverrides = currentPage.stopCancel || currentPage.preventDefault;\n\n    if (this.stopNavigation) {\n      return;\n    }\n\n    currentPage.pageOnCancel.emit();\n    if (!currentPageHasOverrides) {\n      this.onCancel.emit();\n    }\n\n    if (!this.stopCancel && !currentPageHasOverrides) {\n      this.close();\n    }\n  }\n\n  /**\n   * Navigates to a given page in the Wizard. Navigation will invoke the wizard’s default\n   * checks and event emissions.\n   *\n   * The format of the expected ID parameter can be found in the return of the\n   * ClrWizardPage.id getter, usually prefixed with `clr-wizard-page-` and then either a\n   * numeric ID or the ID specified for the `ClrWizardPage` component’s `id` input.\n   */\n  public goTo(pageId: string): void {\n    if (!pageId) {\n      return;\n    }\n\n    this.navService.goTo(pageId);\n  }\n\n  /**\n   * Reset sets all WizardPages to incomplete and sets the first page in the `ClrWizard` to\n   * be the current page, resetting the wizard navigation.\n   * Use `(clrWizardOnReset)` event to reset the data or model of your wizard.\n   */\n  public reset(): void {\n    this.pageCollection.reset();\n    this.onReset.next();\n  }\n\n  private listenForNextPageChanges(): Subscription {\n    return this.navService.movedToNextPage.pipe(filter(() => isPlatformBrowser(this.platformId))).subscribe(() => {\n      this.onMoveNext.emit();\n      this.wizardTitle.nativeElement.focus();\n    });\n  }\n\n  private listenForPreviousPageChanges(): Subscription {\n    return this.navService.movedToPreviousPage.pipe(filter(() => isPlatformBrowser(this.platformId))).subscribe(() => {\n      this.onMovePrevious.emit();\n      this.wizardTitle.nativeElement.focus();\n    });\n  }\n\n  private listenForCancelChanges(): Subscription {\n    return this.navService.notifyWizardCancel.subscribe(() => this.checkAndCancel());\n  }\n\n  private listenForFinishedChanges(): Subscription {\n    return this.navService.wizardFinished.subscribe(() => this.emitWizardFinished());\n  }\n\n  private listenForPageChanges(): Subscription {\n    return this.navService.currentPageChanged.subscribe(() => this.currentPageChanged.emit());\n  }\n\n  private updateNavOnPageChanges(): void {\n    const changes = this.differ.diff(this.pages);\n    if (changes) {\n      changes.forEachAddedItem(() => this.navService.updateNavigation());\n      changes.forEachRemovedItem(() => this.navService.updateNavigation());\n    }\n  }\n\n  private initializeButtons(): void {\n    // Only trigger buttons ready if default is open (inlined)\n    if (this._open) {\n      this.buttonService.buttonsReady = true;\n    }\n  }\n\n  private emitWizardFinished(): void {\n    if (!this.stopNext) {\n      this.forceFinish();\n    }\n    this.wizardFinished.emit();\n  }\n}\n","<!--\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\n<clr-modal\n  [clrModalOpen]=\"_open\"\n  [clrModalSize]=\"size\"\n  [clrModalClosable]=\"closable\"\n  [clrModalStaticBackdrop]=\"true\"\n  [clrModalSkipAnimation]=\"stopModalAnimations\"\n  [clrModalOverrideScrollService]=\"isStatic\"\n  [clrModalPreventClose]=\"true\"\n  (clrModalAlternateClose)=\"modalCancel()\"\n>\n  <nav class=\"modal-nav clr-wizard-stepnav-wrapper\">\n    <h1 class=\"clr-wizard-title\"><ng-content select=\"clr-wizard-title\"></ng-content></h1>\n    <clr-wizard-stepnav></clr-wizard-stepnav>\n  </nav>\n\n  <h2 class=\"modal-title\">\n    <span tabindex=\"-1\" #wizardTitle class=\"modal-title-text\">\n      <ng-template [ngTemplateOutlet]=\"navService.currentPageTitle\"></ng-template>\n    </span>\n\n    <div class=\"modal-header-actions-wrapper\" *ngIf=\"headerActionService.displayHeaderActionsWrapper\">\n      <div *ngIf=\"headerActionService.showWizardHeaderActions\">\n        <ng-content select=\"clr-wizard-header-action\"></ng-content>\n      </div>\n      <div *ngIf=\"headerActionService.currentPageHasHeaderActions\">\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.headerActions\"></ng-template>\n      </div>\n    </div>\n  </h2>\n\n  <div class=\"modal-body\">\n    <main clr-wizard-pages-wrapper class=\"clr-wizard-content\">\n      <ng-content></ng-content>\n    </main>\n  </div>\n  <div class=\"modal-footer clr-wizard-footer\">\n    <div class=\"clr-wizard-footer-buttons\">\n      <div\n        *ngIf=\"navService.currentPage && !navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-content select=\"clr-wizard-button\"></ng-content>\n      </div>\n      <div\n        *ngIf=\"navService.currentPage && navService.currentPage.hasButtons\"\n        class=\"clr-wizard-footer-buttons-wrapper\"\n      >\n        <ng-template [ngTemplateOutlet]=\"navService.currentPage.buttons\"></ng-template>\n      </div>\n    </div>\n  </div>\n</clr-modal>\n"]}

package/esm2020/wizard/wizard.module.mjs

@@ -0,0 +1,72 @@
+/*
+ * 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 { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { ClarityIcons, errorStandardIcon } from '@cds/core/icon';
+import { ClrAlertModule } from '../emphasis/alert/alert.module';
+import { ClrModalModule } from '../modal/modal.module';
+import { ClrWizard } from './wizard';
+import { ClrWizardButton } from './wizard-button';
+import { ClrWizardCustomTags } from './wizard-custom-tags';
+import { ClrWizardHeaderAction } from './wizard-header-action';
+import { ClrWizardPage } from './wizard-page';
+import { ClrWizardPageButtons } from './wizard-page-buttons';
+import { ClrWizardPageHeaderActions } from './wizard-page-header-actions';
+import { ClrWizardPageNavTitle } from './wizard-page-navtitle';
+import { ClrWizardPageTitle } from './wizard-page-title';
+import { ClrWizardStepnav } from './wizard-stepnav';
+import { ClrWizardStepnavItem } from './wizard-stepnav-item';
+import * as i0 from "@angular/core";
+export const CLR_WIZARD_DIRECTIVES = [
+    ClrWizard,
+    ClrWizardPage,
+    ClrWizardStepnav,
+    ClrWizardStepnavItem,
+    ClrWizardButton,
+    ClrWizardHeaderAction,
+    ClrWizardCustomTags,
+    ClrWizardPageTitle,
+    ClrWizardPageNavTitle,
+    ClrWizardPageButtons,
+    ClrWizardPageHeaderActions,
+];
+export class ClrWizardModule {
+    constructor() {
+        ClarityIcons.addIcons(errorStandardIcon);
+    }
+}
+ClrWizardModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizardModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+ClrWizardModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizardModule, declarations: [ClrWizard,
+        ClrWizardPage,
+        ClrWizardStepnav,
+        ClrWizardStepnavItem,
+        ClrWizardButton,
+        ClrWizardHeaderAction,
+        ClrWizardCustomTags,
+        ClrWizardPageTitle,
+        ClrWizardPageNavTitle,
+        ClrWizardPageButtons,
+        ClrWizardPageHeaderActions], imports: [CommonModule, ClrModalModule, ClrAlertModule], exports: [ClrWizard,
+        ClrWizardPage,
+        ClrWizardStepnav,
+        ClrWizardStepnavItem,
+        ClrWizardButton,
+        ClrWizardHeaderAction,
+        ClrWizardCustomTags,
+        ClrWizardPageTitle,
+        ClrWizardPageNavTitle,
+        ClrWizardPageButtons,
+        ClrWizardPageHeaderActions] });
+ClrWizardModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizardModule, imports: [[CommonModule, ClrModalModule, ClrAlertModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.0", ngImport: i0, type: ClrWizardModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [CommonModule, ClrModalModule, ClrAlertModule],
+                    declarations: [CLR_WIZARD_DIRECTIVES],
+                    exports: [CLR_WIZARD_DIRECTIVES],
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoid2l6YXJkLm1vZHVsZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL2FuZ3VsYXIvc3JjL3dpemFyZC93aXphcmQubW9kdWxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7O0dBSUc7QUFFSCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsT0FBTyxFQUFFLFFBQVEsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUN6QyxPQUFPLEVBQUUsWUFBWSxFQUFFLGlCQUFpQixFQUFFLE1BQU0sZ0JBQWdCLENBQUM7QUFFakUsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGdDQUFnQyxDQUFDO0FBQ2hFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUV2RCxPQUFPLEVBQUUsU0FBUyxFQUFFLE1BQU0sVUFBVSxDQUFDO0FBQ3JDLE9BQU8sRUFBRSxlQUFlLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUNsRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxzQkFBc0IsQ0FBQztBQUMzRCxPQUFPLEVBQUUscUJBQXFCLEVBQUUsTUFBTSx3QkFBd0IsQ0FBQztBQUMvRCxPQUFPLEVBQUUsYUFBYSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzlDLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBQzdELE9BQU8sRUFBRSwwQkFBMEIsRUFBRSxNQUFNLDhCQUE4QixDQUFDO0FBQzFFLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHdCQUF3QixDQUFDO0FBQy9ELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLHFCQUFxQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxnQkFBZ0IsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3BELE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHVCQUF1QixDQUFDOztBQUU3RCxNQUFNLENBQUMsTUFBTSxxQkFBcUIsR0FBVTtJQUMxQyxTQUFTO0lBQ1QsYUFBYTtJQUNiLGdCQUFnQjtJQUNoQixvQkFBb0I7SUFDcEIsZUFBZTtJQUNmLHFCQUFxQjtJQUNyQixtQkFBbUI7SUFDbkIsa0JBQWtCO0lBQ2xCLHFCQUFxQjtJQUNyQixvQkFBb0I7SUFDcEIsMEJBQTBCO0NBQzNCLENBQUM7QUFPRixNQUFNLE9BQU8sZUFBZTtJQUMxQjtRQUNFLFlBQVksQ0FBQyxRQUFRLENBQUMsaUJBQWlCLENBQUMsQ0FBQztJQUMzQyxDQUFDOzs0R0FIVSxlQUFlOzZHQUFmLGVBQWUsaUJBbEIxQixTQUFTO1FBQ1QsYUFBYTtRQUNiLGdCQUFnQjtRQUNoQixvQkFBb0I7UUFDcEIsZUFBZTtRQUNmLHFCQUFxQjtRQUNyQixtQkFBbUI7UUFDbkIsa0JBQWtCO1FBQ2xCLHFCQUFxQjtRQUNyQixvQkFBb0I7UUFDcEIsMEJBQTBCLGFBSWhCLFlBQVksRUFBRSxjQUFjLEVBQUUsY0FBYyxhQWR0RCxTQUFTO1FBQ1QsYUFBYTtRQUNiLGdCQUFnQjtRQUNoQixvQkFBb0I7UUFDcEIsZUFBZTtRQUNmLHFCQUFxQjtRQUNyQixtQkFBbUI7UUFDbkIsa0JBQWtCO1FBQ2xCLHFCQUFxQjtRQUNyQixvQkFBb0I7UUFDcEIsMEJBQTBCOzZHQVFmLGVBQWUsWUFKakIsQ0FBQyxZQUFZLEVBQUUsY0FBYyxFQUFFLGNBQWMsQ0FBQzsyRkFJNUMsZUFBZTtrQkFMM0IsUUFBUTttQkFBQztvQkFDUixPQUFPLEVBQUUsQ0FBQyxZQUFZLEVBQUUsY0FBYyxFQUFFLGNBQWMsQ0FBQztvQkFDdkQsWUFBWSxFQUFFLENBQUMscUJBQXFCLENBQUM7b0JBQ3JDLE9BQU8sRUFBRSxDQUFDLHFCQUFxQixDQUFDO2lCQUNqQyIsInNvdXJjZXNDb250ZW50IjpbIi8qXG4gKiBDb3B5cmlnaHQgKGMpIDIwMTYtMjAyMSBWTXdhcmUsIEluYy4gQWxsIFJpZ2h0cyBSZXNlcnZlZC5cbiAqIFRoaXMgc29mdHdhcmUgaXMgcmVsZWFzZWQgdW5kZXIgTUlUIGxpY2Vuc2UuXG4gKiBUaGUgZnVsbCBsaWNlbnNlIGluZm9ybWF0aW9uIGNhbiBiZSBmb3VuZCBpbiBMSUNFTlNFIGluIHRoZSByb290IGRpcmVjdG9yeSBvZiB0aGlzIHByb2plY3QuXG4gKi9cblxuaW1wb3J0IHsgQ29tbW9uTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uJztcbmltcG9ydCB7IE5nTW9kdWxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5pbXBvcnQgeyBDbGFyaXR5SWNvbnMsIGVycm9yU3RhbmRhcmRJY29uIH0gZnJvbSAnQGNkcy9jb3JlL2ljb24nO1xuXG5pbXBvcnQgeyBDbHJBbGVydE1vZHVsZSB9IGZyb20gJy4uL2VtcGhhc2lzL2FsZXJ0L2FsZXJ0Lm1vZHVsZSc7XG5pbXBvcnQgeyBDbHJNb2RhbE1vZHVsZSB9IGZyb20gJy4uL21vZGFsL21vZGFsLm1vZHVsZSc7XG5cbmltcG9ydCB7IENscldpemFyZCB9IGZyb20gJy4vd2l6YXJkJztcbmltcG9ydCB7IENscldpemFyZEJ1dHRvbiB9IGZyb20gJy4vd2l6YXJkLWJ1dHRvbic7XG5pbXBvcnQgeyBDbHJXaXphcmRDdXN0b21UYWdzIH0gZnJvbSAnLi93aXphcmQtY3VzdG9tLXRhZ3MnO1xuaW1wb3J0IHsgQ2xyV2l6YXJkSGVhZGVyQWN0aW9uIH0gZnJvbSAnLi93aXphcmQtaGVhZGVyLWFjdGlvbic7XG5pbXBvcnQgeyBDbHJXaXphcmRQYWdlIH0gZnJvbSAnLi93aXphcmQtcGFnZSc7XG5pbXBvcnQgeyBDbHJXaXphcmRQYWdlQnV0dG9ucyB9IGZyb20gJy4vd2l6YXJkLXBhZ2UtYnV0dG9ucyc7XG5pbXBvcnQgeyBDbHJXaXphcmRQYWdlSGVhZGVyQWN0aW9ucyB9IGZyb20gJy4vd2l6YXJkLXBhZ2UtaGVhZGVyLWFjdGlvbnMnO1xuaW1wb3J0IHsgQ2xyV2l6YXJkUGFnZU5hdlRpdGxlIH0gZnJvbSAnLi93aXphcmQtcGFnZS1uYXZ0aXRsZSc7XG5pbXBvcnQgeyBDbHJXaXphcmRQYWdlVGl0bGUgfSBmcm9tICcuL3dpemFyZC1wYWdlLXRpdGxlJztcbmltcG9ydCB7IENscldpemFyZFN0ZXBuYXYgfSBmcm9tICcuL3dpemFyZC1zdGVwbmF2JztcbmltcG9ydCB7IENscldpemFyZFN0ZXBuYXZJdGVtIH0gZnJvbSAnLi93aXphcmQtc3RlcG5hdi1pdGVtJztcblxuZXhwb3J0IGNvbnN0IENMUl9XSVpBUkRfRElSRUNUSVZFUzogYW55W10gPSBbXG4gIENscldpemFyZCxcbiAgQ2xyV2l6YXJkUGFnZSxcbiAgQ2xyV2l6YXJkU3RlcG5hdixcbiAgQ2xyV2l6YXJkU3RlcG5hdkl0ZW0sXG4gIENscldpemFyZEJ1dHRvbixcbiAgQ2xyV2l6YXJkSGVhZGVyQWN0aW9uLFxuICBDbHJXaXphcmRDdXN0b21UYWdzLFxuICBDbHJXaXphcmRQYWdlVGl0bGUsXG4gIENscldpemFyZFBhZ2VOYXZUaXRsZSxcbiAgQ2xyV2l6YXJkUGFnZUJ1dHRvbnMsXG4gIENscldpemFyZFBhZ2VIZWFkZXJBY3Rpb25zLFxuXTtcblxuQE5nTW9kdWxlKHtcbiAgaW1wb3J0czogW0NvbW1vbk1vZHVsZSwgQ2xyTW9kYWxNb2R1bGUsIENsckFsZXJ0TW9kdWxlXSxcbiAgZGVjbGFyYXRpb25zOiBbQ0xSX1dJWkFSRF9ESVJFQ1RJVkVTXSxcbiAgZXhwb3J0czogW0NMUl9XSVpBUkRfRElSRUNUSVZFU10sXG59KVxuZXhwb3J0IGNsYXNzIENscldpemFyZE1vZHVsZSB7XG4gIGNvbnN0cnVjdG9yKCkge1xuICAgIENsYXJpdHlJY29ucy5hZGRJY29ucyhlcnJvclN0YW5kYXJkSWNvbik7XG4gIH1cbn1cbiJdfQ==