ahcdashboardui/node_modules/@angular/cdk/esm2015/stepper/stepper.js

/**
 * @license
 * Copyright Google LLC All Rights Reserved.
 *
 * Use of this source code is governed by an MIT-style license that can be
 * found in the LICENSE file at https://angular.io/license
 */
import { FocusKeyManager } from '@angular/cdk/a11y';
import { Directionality } from '@angular/cdk/bidi';
import { coerceBooleanProperty, coerceNumberProperty } from '@angular/cdk/coercion';
import { ENTER, hasModifierKey, SPACE } from '@angular/cdk/keycodes';
import { DOCUMENT } from '@angular/common';
import { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, ElementRef, EventEmitter, forwardRef, Inject, InjectionToken, Input, Optional, Output, QueryList, TemplateRef, ViewChild, ViewEncapsulation, } from '@angular/core';
import { _getFocusedElementPierceShadowDom } from '@angular/cdk/platform';
import { of as observableOf, Subject } from 'rxjs';
import { startWith, takeUntil } from 'rxjs/operators';
import { CdkStepHeader } from './step-header';
import { CdkStepLabel } from './step-label';
/** Used to generate unique ID for each stepper component. */
import * as ɵngcc0 from '@angular/core';
import * as ɵngcc1 from '@angular/cdk/bidi';

function CdkStep_ng_template_0_Template(rf, ctx) { if (rf & 1) {
    ɵngcc0.ɵɵprojection(0);
} }
const _c0 = ["*"];
let nextId = 0;
/** Change event emitted on selection changes. */
export class StepperSelectionEvent {
}
/** Enum to represent the different states of the steps. */
export const STEP_STATE = {
    NUMBER: 'number',
    EDIT: 'edit',
    DONE: 'done',
    ERROR: 'error'
};
/** InjectionToken that can be used to specify the global stepper options. */
export const STEPPER_GLOBAL_OPTIONS = new InjectionToken('STEPPER_GLOBAL_OPTIONS');
export class CdkStep {
    constructor(_stepper, stepperOptions) {
        this._stepper = _stepper;
        /** Whether user has attempted to move away from the step. */
        this.interacted = false;
        /** Emits when the user has attempted to move away from the step. */
        this.interactedStream = new EventEmitter();
        this._editable = true;
        this._optional = false;
        this._completedOverride = null;
        this._customError = null;
        this._stepperOptions = stepperOptions ? stepperOptions : {};
        this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;
    }
    /** Whether the user can return to this step once it has been marked as completed. */
    get editable() {
        return this._editable;
    }
    set editable(value) {
        this._editable = coerceBooleanProperty(value);
    }
    /** Whether the completion of step is optional. */
    get optional() {
        return this._optional;
    }
    set optional(value) {
        this._optional = coerceBooleanProperty(value);
    }
    /** Whether step is marked as completed. */
    get completed() {
        return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;
    }
    set completed(value) {
        this._completedOverride = coerceBooleanProperty(value);
    }
    _getDefaultCompleted() {
        return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;
    }
    /** Whether step has an error. */
    get hasError() {
        return this._customError == null ? this._getDefaultError() : this._customError;
    }
    set hasError(value) {
        this._customError = coerceBooleanProperty(value);
    }
    _getDefaultError() {
        return this.stepControl && this.stepControl.invalid && this.interacted;
    }
    /** Selects this step component. */
    select() {
        this._stepper.selected = this;
    }
    /** Resets the step to its initial state. Note that this includes resetting form data. */
    reset() {
        this.interacted = false;
        if (this._completedOverride != null) {
            this._completedOverride = false;
        }
        if (this._customError != null) {
            this._customError = false;
        }
        if (this.stepControl) {
            this.stepControl.reset();
        }
    }
    ngOnChanges() {
        // Since basically all inputs of the MatStep get proxied through the view down to the
        // underlying MatStepHeader, we have to make sure that change detection runs correctly.
        this._stepper._stateChanged();
    }
    _markAsInteracted() {
        if (!this.interacted) {
            this.interacted = true;
            this.interactedStream.emit(this);
        }
    }
    /** Determines whether the error state can be shown. */
    _showError() {
        var _a;
        // We want to show the error state either if the user opted into/out of it using the
        // global options, or if they've explicitly set it through the `hasError` input.
        return (_a = this._stepperOptions.showError) !== null && _a !== void 0 ? _a : this._customError != null;
    }
}
CdkStep.ɵfac = function CdkStep_Factory(t) { return new (t || CdkStep)(ɵngcc0.ɵɵdirectiveInject(forwardRef(() => CdkStepper)), ɵngcc0.ɵɵdirectiveInject(STEPPER_GLOBAL_OPTIONS, 8)); };
CdkStep.ɵcmp = /*@__PURE__*/ ɵngcc0.ɵɵdefineComponent({ type: CdkStep, selectors: [["cdk-step"]], contentQueries: function CdkStep_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
        ɵngcc0.ɵɵcontentQuery(dirIndex, CdkStepLabel, 5);
    } if (rf & 2) {
        let _t;
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.stepLabel = _t.first);
    } }, viewQuery: function CdkStep_Query(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵviewQuery(TemplateRef, 7);
    } if (rf & 2) {
        let _t;
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.content = _t.first);
    } }, inputs: { editable: "editable", optional: "optional", completed: "completed", hasError: "hasError", stepControl: "stepControl", label: "label", errorMessage: "errorMessage", ariaLabel: ["aria-label", "ariaLabel"], ariaLabelledby: ["aria-labelledby", "ariaLabelledby"], state: "state" }, outputs: { interactedStream: "interacted" }, exportAs: ["cdkStep"], features: [ɵngcc0.ɵɵNgOnChangesFeature], ngContentSelectors: _c0, decls: 1, vars: 0, template: function CdkStep_Template(rf, ctx) { if (rf & 1) {
        ɵngcc0.ɵɵprojectionDef();
        ɵngcc0.ɵɵtemplate(0, CdkStep_ng_template_0_Template, 1, 0, "ng-template");
    } }, encapsulation: 2, changeDetection: 0 });
CdkStep.ctorParameters = () => [
    { type: CdkStepper, decorators: [{ type: Inject, args: [forwardRef(() => CdkStepper),] }] },
    { type: undefined, decorators: [{ type: Optional }, { type: Inject, args: [STEPPER_GLOBAL_OPTIONS,] }] }
];
CdkStep.propDecorators = {
    stepLabel: [{ type: ContentChild, args: [CdkStepLabel,] }],
    content: [{ type: ViewChild, args: [TemplateRef, { static: true },] }],
    stepControl: [{ type: Input }],
    interactedStream: [{ type: Output, args: ['interacted',] }],
    label: [{ type: Input }],
    errorMessage: [{ type: Input }],
    ariaLabel: [{ type: Input, args: ['aria-label',] }],
    ariaLabelledby: [{ type: Input, args: ['aria-labelledby',] }],
    state: [{ type: Input }],
    editable: [{ type: Input }],
    optional: [{ type: Input }],
    completed: [{ type: Input }],
    hasError: [{ type: Input }]
};
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkStep, [{
        type: Component,
        args: [{
                selector: 'cdk-step',
                exportAs: 'cdkStep',
                template: '<ng-template><ng-content></ng-content></ng-template>',
                encapsulation: ViewEncapsulation.None,
                changeDetection: ChangeDetectionStrategy.OnPush
            }]
    }], function () { return [{ type: CdkStepper, decorators: [{
                type: Inject,
                args: [forwardRef(() => CdkStepper)]
            }] }, { type: undefined, decorators: [{
                type: Optional
            }, {
                type: Inject,
                args: [STEPPER_GLOBAL_OPTIONS]
            }] }]; }, { interactedStream: [{
            type: Output,
            args: ['interacted']
        }], editable: [{
            type: Input
        }], optional: [{
            type: Input
        }], completed: [{
            type: Input
        }], hasError: [{
            type: Input
        }], stepLabel: [{
            type: ContentChild,
            args: [CdkStepLabel]
        }], content: [{
            type: ViewChild,
            args: [TemplateRef, { static: true }]
        }], stepControl: [{
            type: Input
        }], label: [{
            type: Input
        }], errorMessage: [{
            type: Input
        }], ariaLabel: [{
            type: Input,
            args: ['aria-label']
        }], ariaLabelledby: [{
            type: Input,
            args: ['aria-labelledby']
        }], state: [{
            type: Input
        }] }); })();
export class CdkStepper {
    constructor(_dir, _changeDetectorRef, _elementRef, 
    /**
     * @deprecated No longer in use, to be removed.
     * @breaking-change 13.0.0
     */
    _document) {
        this._dir = _dir;
        this._changeDetectorRef = _changeDetectorRef;
        this._elementRef = _elementRef;
        /** Emits when the component is destroyed. */
        this._destroyed = new Subject();
        /** Steps that belong to the current stepper, excluding ones from nested steppers. */
        this.steps = new QueryList();
        /** List of step headers sorted based on their DOM order. */
        this._sortedHeaders = new QueryList();
        this._linear = false;
        this._selectedIndex = 0;
        /** Event emitted when the selected step has changed. */
        this.selectionChange = new EventEmitter();
        /**
         * @deprecated To be turned into a private property. Use `orientation` instead.
         * @breaking-change 13.0.0
         */
        this._orientation = 'horizontal';
        this._groupId = nextId++;
    }
    /** Whether the validity of previous steps should be checked or not. */
    get linear() {
        return this._linear;
    }
    set linear(value) {
        this._linear = coerceBooleanProperty(value);
    }
    /** The index of the selected step. */
    get selectedIndex() {
        return this._selectedIndex;
    }
    set selectedIndex(index) {
        var _a;
        const newIndex = coerceNumberProperty(index);
        if (this.steps && this._steps) {
            // Ensure that the index can't be out of bounds.
            if (!this._isValidIndex(index) && (typeof ngDevMode === 'undefined' || ngDevMode)) {
                throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');
            }
            (_a = this.selected) === null || _a === void 0 ? void 0 : _a._markAsInteracted();
            if (this._selectedIndex !== newIndex && !this._anyControlsInvalidOrPending(newIndex) &&
                (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {
                this._updateSelectedItemIndex(index);
            }
        }
        else {
            this._selectedIndex = newIndex;
        }
    }
    /** The step that is selected. */
    get selected() {
        return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined;
    }
    set selected(step) {
        this.selectedIndex = (step && this.steps) ? this.steps.toArray().indexOf(step) : -1;
    }
    /** Orientation of the stepper. */
    get orientation() { return this._orientation; }
    set orientation(value) {
        // This is a protected method so that `MatSteppter` can hook into it.
        this._orientation = value;
        if (this._keyManager) {
            this._keyManager.withVerticalOrientation(value === 'vertical');
        }
    }
    ngAfterContentInit() {
        this._steps.changes
            .pipe(startWith(this._steps), takeUntil(this._destroyed))
            .subscribe((steps) => {
            this.steps.reset(steps.filter(step => step._stepper === this));
            this.steps.notifyOnChanges();
        });
    }
    ngAfterViewInit() {
        // If the step headers are defined outside of the `ngFor` that renders the steps, like in the
        // Material stepper, they won't appear in the `QueryList` in the same order as they're
        // rendered in the DOM which will lead to incorrect keyboard navigation. We need to sort
        // them manually to ensure that they're correct. Alternatively, we can change the Material
        // template to inline the headers in the `ngFor`, but that'll result in a lot of
        // code duplciation. See #23539.
        this._stepHeader.changes
            .pipe(startWith(this._stepHeader), takeUntil(this._destroyed))
            .subscribe((headers) => {
            this._sortedHeaders.reset(headers.toArray().sort((a, b) => {
                const documentPosition = a._elementRef.nativeElement.compareDocumentPosition(b._elementRef.nativeElement);
                // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.
                // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition
                // tslint:disable-next-line:no-bitwise
                return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;
            }));
            this._sortedHeaders.notifyOnChanges();
        });
        // Note that while the step headers are content children by default, any components that
        // extend this one might have them as view children. We initialize the keyboard handling in
        // AfterViewInit so we're guaranteed for both view and content children to be defined.
        this._keyManager = new FocusKeyManager(this._sortedHeaders)
            .withWrap()
            .withHomeAndEnd()
            .withVerticalOrientation(this._orientation === 'vertical');
        (this._dir ? this._dir.change : observableOf())
            .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))
            .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));
        this._keyManager.updateActiveItem(this._selectedIndex);
        // No need to `takeUntil` here, because we're the ones destroying `steps`.
        this.steps.changes.subscribe(() => {
            if (!this.selected) {
                this._selectedIndex = Math.max(this._selectedIndex - 1, 0);
            }
        });
        // The logic which asserts that the selected index is within bounds doesn't run before the
        // steps are initialized, because we don't how many steps there are yet so we may have an
        // invalid index on init. If that's the case, auto-correct to the default so we don't throw.
        if (!this._isValidIndex(this._selectedIndex)) {
            this._selectedIndex = 0;
        }
    }
    ngOnDestroy() {
        this.steps.destroy();
        this._sortedHeaders.destroy();
        this._destroyed.next();
        this._destroyed.complete();
    }
    /** Selects and focuses the next step in list. */
    next() {
        this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);
    }
    /** Selects and focuses the previous step in list. */
    previous() {
        this.selectedIndex = Math.max(this._selectedIndex - 1, 0);
    }
    /** Resets the stepper to its initial state. Note that this includes clearing form data. */
    reset() {
        this._updateSelectedItemIndex(0);
        this.steps.forEach(step => step.reset());
        this._stateChanged();
    }
    /** Returns a unique id for each step label element. */
    _getStepLabelId(i) {
        return `cdk-step-label-${this._groupId}-${i}`;
    }
    /** Returns unique id for each step content element. */
    _getStepContentId(i) {
        return `cdk-step-content-${this._groupId}-${i}`;
    }
    /** Marks the component to be change detected. */
    _stateChanged() {
        this._changeDetectorRef.markForCheck();
    }
    /** Returns position state of the step with the given index. */
    _getAnimationDirection(index) {
        const position = index - this._selectedIndex;
        if (position < 0) {
            return this._layoutDirection() === 'rtl' ? 'next' : 'previous';
        }
        else if (position > 0) {
            return this._layoutDirection() === 'rtl' ? 'previous' : 'next';
        }
        return 'current';
    }
    /** Returns the type of icon to be displayed. */
    _getIndicatorType(index, state = STEP_STATE.NUMBER) {
        const step = this.steps.toArray()[index];
        const isCurrentStep = this._isCurrentStep(index);
        return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :
            this._getGuidelineLogic(step, isCurrentStep, state);
    }
    _getDefaultIndicatorLogic(step, isCurrentStep) {
        if (step._showError() && step.hasError && !isCurrentStep) {
            return STEP_STATE.ERROR;
        }
        else if (!step.completed || isCurrentStep) {
            return STEP_STATE.NUMBER;
        }
        else {
            return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;
        }
    }
    _getGuidelineLogic(step, isCurrentStep, state = STEP_STATE.NUMBER) {
        if (step._showError() && step.hasError && !isCurrentStep) {
            return STEP_STATE.ERROR;
        }
        else if (step.completed && !isCurrentStep) {
            return STEP_STATE.DONE;
        }
        else if (step.completed && isCurrentStep) {
            return state;
        }
        else if (step.editable && isCurrentStep) {
            return STEP_STATE.EDIT;
        }
        else {
            return state;
        }
    }
    _isCurrentStep(index) {
        return this._selectedIndex === index;
    }
    /** Returns the index of the currently-focused step header. */
    _getFocusIndex() {
        return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;
    }
    _updateSelectedItemIndex(newIndex) {
        const stepsArray = this.steps.toArray();
        this.selectionChange.emit({
            selectedIndex: newIndex,
            previouslySelectedIndex: this._selectedIndex,
            selectedStep: stepsArray[newIndex],
            previouslySelectedStep: stepsArray[this._selectedIndex],
        });
        // If focus is inside the stepper, move it to the next header, otherwise it may become
        // lost when the active step content is hidden. We can't be more granular with the check
        // (e.g. checking whether focus is inside the active step), because we don't have a
        // reference to the elements that are rendering out the content.
        this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :
            this._keyManager.updateActiveItem(newIndex);
        this._selectedIndex = newIndex;
        this._stateChanged();
    }
    _onKeydown(event) {
        const hasModifier = hasModifierKey(event);
        const keyCode = event.keyCode;
        const manager = this._keyManager;
        if (manager.activeItemIndex != null && !hasModifier &&
            (keyCode === SPACE || keyCode === ENTER)) {
            this.selectedIndex = manager.activeItemIndex;
            event.preventDefault();
        }
        else {
            manager.onKeydown(event);
        }
    }
    _anyControlsInvalidOrPending(index) {
        if (this._linear && index >= 0) {
            return this.steps.toArray().slice(0, index).some(step => {
                const control = step.stepControl;
                const isIncomplete = control ? (control.invalid || control.pending || !step.interacted) : !step.completed;
                return isIncomplete && !step.optional && !step._completedOverride;
            });
        }
        return false;
    }
    _layoutDirection() {
        return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';
    }
    /** Checks whether the stepper contains the focused element. */
    _containsFocus() {
        const stepperElement = this._elementRef.nativeElement;
        const focusedElement = _getFocusedElementPierceShadowDom();
        return stepperElement === focusedElement || stepperElement.contains(focusedElement);
    }
    /** Checks whether the passed-in index is a valid step index. */
    _isValidIndex(index) {
        return index > -1 && (!this.steps || index < this.steps.length);
    }
}
CdkStepper.ɵfac = function CdkStepper_Factory(t) { return new (t || CdkStepper)(ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Directionality, 8), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(DOCUMENT)); };
CdkStepper.ɵdir = /*@__PURE__*/ ɵngcc0.ɵɵdefineDirective({ type: CdkStepper, selectors: [["", "cdkStepper", ""]], contentQueries: function CdkStepper_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
        ɵngcc0.ɵɵcontentQuery(dirIndex, CdkStep, 5);
        ɵngcc0.ɵɵcontentQuery(dirIndex, CdkStepHeader, 5);
    } if (rf & 2) {
        let _t;
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._steps = _t);
        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx._stepHeader = _t);
    } }, inputs: { linear: "linear", selectedIndex: "selectedIndex", selected: "selected", orientation: "orientation" }, outputs: { selectionChange: "selectionChange" }, exportAs: ["cdkStepper"] });
CdkStepper.ctorParameters = () => [
    { type: Directionality, decorators: [{ type: Optional }] },
    { type: ChangeDetectorRef },
    { type: ElementRef },
    { type: undefined, decorators: [{ type: Inject, args: [DOCUMENT,] }] }
];
CdkStepper.propDecorators = {
    _steps: [{ type: ContentChildren, args: [CdkStep, { descendants: true },] }],
    _stepHeader: [{ type: ContentChildren, args: [CdkStepHeader, { descendants: true },] }],
    linear: [{ type: Input }],
    selectedIndex: [{ type: Input }],
    selected: [{ type: Input }],
    selectionChange: [{ type: Output }],
    orientation: [{ type: Input }]
};
(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(CdkStepper, [{
        type: Directive,
        args: [{
                selector: '[cdkStepper]',
                exportAs: 'cdkStepper'
            }]
    }], function () { return [{ type: ɵngcc1.Directionality, decorators: [{
                type: Optional
            }] }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc0.ElementRef }, { type: undefined, decorators: [{
                type: Inject,
                args: [DOCUMENT]
            }] }]; }, { selectionChange: [{
            type: Output
        }], linear: [{
            type: Input
        }], selectedIndex: [{
            type: Input
        }], selected: [{
            type: Input
        }], orientation: [{
            type: Input
        }], _steps: [{
            type: ContentChildren,
            args: [CdkStep, { descendants: true }]
        }], _stepHeader: [{
            type: ContentChildren,
            args: [CdkStepHeader, { descendants: true }]
        }] }); })();

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"stepper.js","sources":["../../../../../../src/cdk/stepper/stepper.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {FocusableOption, FocusKeyManager} from '@angular/cdk/a11y';\nimport {Direction, Directionality} from '@angular/cdk/bidi';\nimport {\n  BooleanInput,\n  coerceBooleanProperty,\n  coerceNumberProperty,\n  NumberInput\n} from '@angular/cdk/coercion';\nimport {ENTER, hasModifierKey, SPACE} from '@angular/cdk/keycodes';\nimport {DOCUMENT} from '@angular/common';\nimport {\n  AfterViewInit,\n  ChangeDetectionStrategy,\n  ChangeDetectorRef,\n  Component,\n  ContentChild,\n  ContentChildren,\n  Directive,\n  ElementRef,\n  EventEmitter,\n  forwardRef,\n  Inject,\n  InjectionToken,\n  Input,\n  OnChanges,\n  OnDestroy,\n  Optional,\n  Output,\n  QueryList,\n  TemplateRef,\n  ViewChild,\n  ViewEncapsulation,\n  AfterContentInit,\n} from '@angular/core';\nimport {_getFocusedElementPierceShadowDom} from '@angular/cdk/platform';\nimport {Observable, of as observableOf, Subject} from 'rxjs';\nimport {startWith, takeUntil} from 'rxjs/operators';\n\nimport {CdkStepHeader} from './step-header';\nimport {CdkStepLabel} from './step-label';\n\n/** Used to generate unique ID for each stepper component. */\nlet nextId = 0;\n\n/**\n * Position state of the content of each step in stepper that is used for transitioning\n * the content into correct position upon step selection change.\n */\nexport type StepContentPositionState = 'previous'|'current'|'next';\n\n/** Possible orientation of a stepper. */\nexport type StepperOrientation = 'horizontal'|'vertical';\n\n/** Change event emitted on selection changes. */\nexport class StepperSelectionEvent {\n  /** Index of the step now selected. */\n  selectedIndex: number;\n\n  /** Index of the step previously selected. */\n  previouslySelectedIndex: number;\n\n  /** The step instance now selected. */\n  selectedStep: CdkStep;\n\n  /** The step instance previously selected. */\n  previouslySelectedStep: CdkStep;\n}\n\n/** The state of each step. */\nexport type StepState = 'number'|'edit'|'done'|'error'|string;\n\n/** Enum to represent the different states of the steps. */\nexport const STEP_STATE = {\n  NUMBER: 'number',\n  EDIT: 'edit',\n  DONE: 'done',\n  ERROR: 'error'\n};\n\n/** InjectionToken that can be used to specify the global stepper options. */\nexport const STEPPER_GLOBAL_OPTIONS = new InjectionToken<StepperOptions>('STEPPER_GLOBAL_OPTIONS');\n\n/** Configurable options for stepper. */\nexport interface StepperOptions {\n  /**\n   * Whether the stepper should display an error state or not.\n   * Default behavior is assumed to be false.\n   */\n  showError?: boolean;\n\n  /**\n   * Whether the stepper should display the default indicator type\n   * or not.\n   * Default behavior is assumed to be true.\n   */\n  displayDefaultIndicatorType?: boolean;\n}\n\n@Component({\n  selector: 'cdk-step',\n  exportAs: 'cdkStep',\n  template: '<ng-template><ng-content></ng-content></ng-template>',\n  encapsulation: ViewEncapsulation.None,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n})\nexport class CdkStep implements OnChanges {\n  private _stepperOptions: StepperOptions;\n  _displayDefaultIndicatorType: boolean;\n\n  /** Template for step label if it exists. */\n  @ContentChild(CdkStepLabel) stepLabel: CdkStepLabel;\n\n  /** Template for step content. */\n  @ViewChild(TemplateRef, {static: true}) content: TemplateRef<any>;\n\n  /** The top level abstract control of the step. */\n  @Input() stepControl: AbstractControlLike;\n\n  /** Whether user has attempted to move away from the step. */\n  interacted = false;\n\n  /** Emits when the user has attempted to move away from the step. */\n  @Output('interacted')\n  readonly interactedStream: EventEmitter<CdkStep> = new EventEmitter<CdkStep>();\n\n  /** Plain text label of the step. */\n  @Input() label: string;\n\n  /** Error message to display when there's an error. */\n  @Input() errorMessage: string;\n\n  /** Aria label for the tab. */\n  @Input('aria-label') ariaLabel: string;\n\n  /**\n   * Reference to the element that the tab is labelled by.\n   * Will be cleared if `aria-label` is set at the same time.\n   */\n  @Input('aria-labelledby') ariaLabelledby: string;\n\n  /** State of the step. */\n  @Input() state: StepState;\n\n  /** Whether the user can return to this step once it has been marked as completed. */\n  @Input()\n  get editable(): boolean {\n    return this._editable;\n  }\n  set editable(value: boolean) {\n    this._editable = coerceBooleanProperty(value);\n  }\n  private _editable = true;\n\n  /** Whether the completion of step is optional. */\n  @Input()\n  get optional(): boolean {\n    return this._optional;\n  }\n  set optional(value: boolean) {\n    this._optional = coerceBooleanProperty(value);\n  }\n  private _optional = false;\n\n  /** Whether step is marked as completed. */\n  @Input()\n  get completed(): boolean {\n    return this._completedOverride == null ? this._getDefaultCompleted() : this._completedOverride;\n  }\n  set completed(value: boolean) {\n    this._completedOverride = coerceBooleanProperty(value);\n  }\n  _completedOverride: boolean|null = null;\n\n  private _getDefaultCompleted() {\n    return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;\n  }\n\n  /** Whether step has an error. */\n  @Input()\n  get hasError(): boolean {\n    return this._customError == null ? this._getDefaultError() : this._customError;\n  }\n  set hasError(value: boolean) {\n    this._customError = coerceBooleanProperty(value);\n  }\n  private _customError: boolean|null = null;\n\n  private _getDefaultError() {\n    return this.stepControl && this.stepControl.invalid && this.interacted;\n  }\n\n  constructor(\n      @Inject(forwardRef(() => CdkStepper)) public _stepper: CdkStepper,\n      @Optional() @Inject(STEPPER_GLOBAL_OPTIONS) stepperOptions?: StepperOptions) {\n    this._stepperOptions = stepperOptions ? stepperOptions : {};\n    this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false;\n  }\n\n  /** Selects this step component. */\n  select(): void {\n    this._stepper.selected = this;\n  }\n\n  /** Resets the step to its initial state. Note that this includes resetting form data. */\n  reset(): void {\n    this.interacted = false;\n\n    if (this._completedOverride != null) {\n      this._completedOverride = false;\n    }\n\n    if (this._customError != null) {\n      this._customError = false;\n    }\n\n    if (this.stepControl) {\n      this.stepControl.reset();\n    }\n  }\n\n  ngOnChanges() {\n    // Since basically all inputs of the MatStep get proxied through the view down to the\n    // underlying MatStepHeader, we have to make sure that change detection runs correctly.\n    this._stepper._stateChanged();\n  }\n\n  _markAsInteracted() {\n    if (!this.interacted) {\n      this.interacted = true;\n      this.interactedStream.emit(this);\n    }\n  }\n\n  /** Determines whether the error state can be shown. */\n  _showError(): boolean {\n    // We want to show the error state either if the user opted into/out of it using the\n    // global options, or if they've explicitly set it through the `hasError` input.\n    return this._stepperOptions.showError ?? this._customError != null;\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n}\n\n@Directive({\n  selector: '[cdkStepper]',\n  exportAs: 'cdkStepper',\n})\nexport class CdkStepper implements AfterContentInit, AfterViewInit, OnDestroy {\n  /** Emits when the component is destroyed. */\n  protected readonly _destroyed = new Subject<void>();\n\n  /** Used for managing keyboard focus. */\n  private _keyManager: FocusKeyManager<FocusableOption>;\n\n  /** Full list of steps inside the stepper, including inside nested steppers. */\n  @ContentChildren(CdkStep, {descendants: true}) _steps: QueryList<CdkStep>;\n\n  /** Steps that belong to the current stepper, excluding ones from nested steppers. */\n  readonly steps: QueryList<CdkStep> = new QueryList<CdkStep>();\n\n  /** The list of step headers of the steps in the stepper. */\n  @ContentChildren(CdkStepHeader, {descendants: true}) _stepHeader: QueryList<CdkStepHeader>;\n\n  /** List of step headers sorted based on their DOM order. */\n  private _sortedHeaders = new QueryList<CdkStepHeader>();\n\n  /** Whether the validity of previous steps should be checked or not. */\n  @Input()\n  get linear(): boolean {\n    return this._linear;\n  }\n  set linear(value: boolean) {\n    this._linear = coerceBooleanProperty(value);\n  }\n  private _linear = false;\n\n  /** The index of the selected step. */\n  @Input()\n  get selectedIndex() {\n    return this._selectedIndex;\n  }\n  set selectedIndex(index: number) {\n    const newIndex = coerceNumberProperty(index);\n\n    if (this.steps && this._steps) {\n      // Ensure that the index can't be out of bounds.\n      if (!this._isValidIndex(index) && (typeof ngDevMode === 'undefined' || ngDevMode)) {\n        throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.');\n      }\n\n      this.selected?._markAsInteracted();\n\n      if (this._selectedIndex !== newIndex && !this._anyControlsInvalidOrPending(newIndex) &&\n          (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) {\n        this._updateSelectedItemIndex(index);\n      }\n    } else {\n      this._selectedIndex = newIndex;\n    }\n  }\n  private _selectedIndex = 0;\n\n  /** The step that is selected. */\n  @Input()\n  get selected(): CdkStep | undefined {\n    return this.steps ? this.steps.toArray()[this.selectedIndex] : undefined;\n  }\n  set selected(step: CdkStep | undefined) {\n    this.selectedIndex = (step && this.steps) ? this.steps.toArray().indexOf(step) : -1;\n  }\n\n  /** Event emitted when the selected step has changed. */\n  @Output() readonly selectionChange = new EventEmitter<StepperSelectionEvent>();\n\n  /** Used to track unique ID for each stepper component. */\n  _groupId: number;\n\n  /** Orientation of the stepper. */\n  @Input()\n  get orientation(): StepperOrientation { return this._orientation; }\n  set orientation(value: StepperOrientation) {\n    // This is a protected method so that `MatSteppter` can hook into it.\n    this._orientation = value;\n\n    if (this._keyManager) {\n      this._keyManager.withVerticalOrientation(value === 'vertical');\n    }\n  }\n\n  /**\n   * @deprecated To be turned into a private property. Use `orientation` instead.\n   * @breaking-change 13.0.0\n   */\n  protected _orientation: StepperOrientation = 'horizontal';\n\n  constructor(\n      @Optional() private _dir: Directionality, private _changeDetectorRef: ChangeDetectorRef,\n      private _elementRef: ElementRef<HTMLElement>,\n      /**\n       * @deprecated No longer in use, to be removed.\n       * @breaking-change 13.0.0\n       */\n      @Inject(DOCUMENT) _document: any) {\n    this._groupId = nextId++;\n  }\n\n  ngAfterContentInit() {\n    this._steps.changes\n      .pipe(startWith(this._steps), takeUntil(this._destroyed))\n      .subscribe((steps: QueryList<CdkStep>) => {\n        this.steps.reset(steps.filter(step => step._stepper === this));\n        this.steps.notifyOnChanges();\n      });\n  }\n\n  ngAfterViewInit() {\n    // If the step headers are defined outside of the `ngFor` that renders the steps, like in the\n    // Material stepper, they won't appear in the `QueryList` in the same order as they're\n    // rendered in the DOM which will lead to incorrect keyboard navigation. We need to sort\n    // them manually to ensure that they're correct. Alternatively, we can change the Material\n    // template to inline the headers in the `ngFor`, but that'll result in a lot of\n    // code duplciation. See #23539.\n    this._stepHeader.changes\n      .pipe(startWith(this._stepHeader), takeUntil(this._destroyed))\n      .subscribe((headers: QueryList<CdkStepHeader>) => {\n        this._sortedHeaders.reset(headers.toArray().sort((a, b) => {\n          const documentPosition =\n            a._elementRef.nativeElement.compareDocumentPosition(b._elementRef.nativeElement);\n\n          // `compareDocumentPosition` returns a bitmask so we have to use a bitwise operator.\n          // https://developer.mozilla.org/en-US/docs/Web/API/Node/compareDocumentPosition\n          // tslint:disable-next-line:no-bitwise\n          return documentPosition & Node.DOCUMENT_POSITION_FOLLOWING ? -1 : 1;\n        }));\n        this._sortedHeaders.notifyOnChanges();\n      });\n\n    // Note that while the step headers are content children by default, any components that\n    // extend this one might have them as view children. We initialize the keyboard handling in\n    // AfterViewInit so we're guaranteed for both view and content children to be defined.\n    this._keyManager = new FocusKeyManager<FocusableOption>(this._sortedHeaders)\n                           .withWrap()\n                           .withHomeAndEnd()\n                           .withVerticalOrientation(this._orientation === 'vertical');\n\n    (this._dir ? (this._dir.change as Observable<Direction>) : observableOf<Direction>())\n        .pipe(startWith(this._layoutDirection()), takeUntil(this._destroyed))\n        .subscribe(direction => this._keyManager.withHorizontalOrientation(direction));\n\n    this._keyManager.updateActiveItem(this._selectedIndex);\n\n    // No need to `takeUntil` here, because we're the ones destroying `steps`.\n    this.steps.changes.subscribe(() => {\n      if (!this.selected) {\n        this._selectedIndex = Math.max(this._selectedIndex - 1, 0);\n      }\n    });\n\n    // The logic which asserts that the selected index is within bounds doesn't run before the\n    // steps are initialized, because we don't how many steps there are yet so we may have an\n    // invalid index on init. If that's the case, auto-correct to the default so we don't throw.\n    if (!this._isValidIndex(this._selectedIndex)) {\n      this._selectedIndex = 0;\n    }\n  }\n\n  ngOnDestroy() {\n    this.steps.destroy();\n    this._sortedHeaders.destroy();\n    this._destroyed.next();\n    this._destroyed.complete();\n  }\n\n  /** Selects and focuses the next step in list. */\n  next(): void {\n    this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1);\n  }\n\n  /** Selects and focuses the previous step in list. */\n  previous(): void {\n    this.selectedIndex = Math.max(this._selectedIndex - 1, 0);\n  }\n\n  /** Resets the stepper to its initial state. Note that this includes clearing form data. */\n  reset(): void {\n    this._updateSelectedItemIndex(0);\n    this.steps.forEach(step => step.reset());\n    this._stateChanged();\n  }\n\n  /** Returns a unique id for each step label element. */\n  _getStepLabelId(i: number): string {\n    return `cdk-step-label-${this._groupId}-${i}`;\n  }\n\n  /** Returns unique id for each step content element. */\n  _getStepContentId(i: number): string {\n    return `cdk-step-content-${this._groupId}-${i}`;\n  }\n\n  /** Marks the component to be change detected. */\n  _stateChanged() {\n    this._changeDetectorRef.markForCheck();\n  }\n\n  /** Returns position state of the step with the given index. */\n  _getAnimationDirection(index: number): StepContentPositionState {\n    const position = index - this._selectedIndex;\n    if (position < 0) {\n      return this._layoutDirection() === 'rtl' ? 'next' : 'previous';\n    } else if (position > 0) {\n      return this._layoutDirection() === 'rtl' ? 'previous' : 'next';\n    }\n    return 'current';\n  }\n\n  /** Returns the type of icon to be displayed. */\n  _getIndicatorType(index: number, state: StepState = STEP_STATE.NUMBER): StepState {\n    const step = this.steps.toArray()[index];\n    const isCurrentStep = this._isCurrentStep(index);\n\n    return step._displayDefaultIndicatorType ? this._getDefaultIndicatorLogic(step, isCurrentStep) :\n                                               this._getGuidelineLogic(step, isCurrentStep, state);\n  }\n\n  private _getDefaultIndicatorLogic(step: CdkStep, isCurrentStep: boolean): StepState {\n    if (step._showError() && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (!step.completed || isCurrentStep) {\n      return STEP_STATE.NUMBER;\n    } else {\n      return step.editable ? STEP_STATE.EDIT : STEP_STATE.DONE;\n    }\n  }\n\n  private _getGuidelineLogic(\n      step: CdkStep, isCurrentStep: boolean, state: StepState = STEP_STATE.NUMBER): StepState {\n    if (step._showError() && step.hasError && !isCurrentStep) {\n      return STEP_STATE.ERROR;\n    } else if (step.completed && !isCurrentStep) {\n      return STEP_STATE.DONE;\n    } else if (step.completed && isCurrentStep) {\n      return state;\n    } else if (step.editable && isCurrentStep) {\n      return STEP_STATE.EDIT;\n    } else {\n      return state;\n    }\n  }\n\n  private _isCurrentStep(index: number) {\n    return this._selectedIndex === index;\n  }\n\n  /** Returns the index of the currently-focused step header. */\n  _getFocusIndex() {\n    return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex;\n  }\n\n  private _updateSelectedItemIndex(newIndex: number): void {\n    const stepsArray = this.steps.toArray();\n    this.selectionChange.emit({\n      selectedIndex: newIndex,\n      previouslySelectedIndex: this._selectedIndex,\n      selectedStep: stepsArray[newIndex],\n      previouslySelectedStep: stepsArray[this._selectedIndex],\n    });\n\n    // If focus is inside the stepper, move it to the next header, otherwise it may become\n    // lost when the active step content is hidden. We can't be more granular with the check\n    // (e.g. checking whether focus is inside the active step), because we don't have a\n    // reference to the elements that are rendering out the content.\n    this._containsFocus() ? this._keyManager.setActiveItem(newIndex) :\n                            this._keyManager.updateActiveItem(newIndex);\n\n    this._selectedIndex = newIndex;\n    this._stateChanged();\n  }\n\n  _onKeydown(event: KeyboardEvent) {\n    const hasModifier = hasModifierKey(event);\n    const keyCode = event.keyCode;\n    const manager = this._keyManager;\n\n    if (manager.activeItemIndex != null && !hasModifier &&\n        (keyCode === SPACE || keyCode === ENTER)) {\n      this.selectedIndex = manager.activeItemIndex;\n      event.preventDefault();\n    } else {\n      manager.onKeydown(event);\n    }\n  }\n\n  private _anyControlsInvalidOrPending(index: number): boolean {\n    if (this._linear && index >= 0) {\n      return this.steps.toArray().slice(0, index).some(step => {\n        const control = step.stepControl;\n        const isIncomplete =\n            control ? (control.invalid || control.pending || !step.interacted) : !step.completed;\n        return isIncomplete && !step.optional && !step._completedOverride;\n      });\n    }\n\n    return false;\n  }\n\n  private _layoutDirection(): Direction {\n    return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n  }\n\n  /** Checks whether the stepper contains the focused element. */\n  private _containsFocus(): boolean {\n    const stepperElement = this._elementRef.nativeElement;\n    const focusedElement = _getFocusedElementPierceShadowDom();\n    return stepperElement === focusedElement || stepperElement.contains(focusedElement);\n  }\n\n  /** Checks whether the passed-in index is a valid step index. */\n  private _isValidIndex(index: number): boolean {\n    return index > -1 && (!this.steps || index < this.steps.length);\n  }\n\n  static ngAcceptInputType_editable: BooleanInput;\n  static ngAcceptInputType_optional: BooleanInput;\n  static ngAcceptInputType_completed: BooleanInput;\n  static ngAcceptInputType_hasError: BooleanInput;\n  static ngAcceptInputType_linear: BooleanInput;\n  static ngAcceptInputType_selectedIndex: NumberInput;\n}\n\n\n/**\n * Simplified representation of an \"AbstractControl\" from @angular/forms.\n * Used to avoid having to bring in @angular/forms for a single optional interface.\n * @docs-private\n */\ninterface AbstractControlLike {\n  asyncValidator: ((control: any) => any) | null;\n  dirty: boolean;\n  disabled: boolean;\n  enabled: boolean;\n  errors: {[key: string]: any} | null;\n  invalid: boolean;\n  parent: any;\n  pending: boolean;\n  pristine: boolean;\n  root: AbstractControlLike;\n  status: string;\n  readonly statusChanges: Observable<any>;\n  touched: boolean;\n  untouched: boolean;\n  updateOn: any;\n  valid: boolean;\n  validator: ((control: any) => any) | null;\n  value: any;\n  readonly valueChanges: Observable<any>;\n  clearAsyncValidators(): void;\n  clearValidators(): void;\n  disable(opts?: any): void;\n  enable(opts?: any): void;\n  get(path: (string | number)[] | string): AbstractControlLike | null;\n  getError(errorCode: string, path?: (string | number)[] | string): any;\n  hasError(errorCode: string, path?: (string | number)[] | string): boolean;\n  markAllAsTouched(): void;\n  markAsDirty(opts?: any): void;\n  markAsPending(opts?: any): void;\n  markAsPristine(opts?: any): void;\n  markAsTouched(opts?: any): void;\n  markAsUntouched(opts?: any): void;\n  patchValue(value: any, options?: Object): void;\n  reset(value?: any, options?: Object): void;\n  setAsyncValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setErrors(errors: {[key: string]: any} | null, opts?: any): void;\n  setParent(parent: any): void;\n  setValidators(newValidator: (control: any) => any |\n    ((control: any) => any)[] | null): void;\n  setValue(value: any, options?: Object): void;\n  updateValueAndValidity(opts?: any): void;\n  patchValue(value: any, options?: any): void;\n  reset(formState?: any, options?: any): void;\n  setValue(value: any, options?: any): void;\n}\n"]}