| /** |
| * @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 |
| */ |
| (function (global, factory) { |
| typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/cdk/a11y'), require('@angular/cdk/bidi'), require('@angular/cdk/coercion'), require('@angular/cdk/keycodes'), require('@angular/common'), require('rxjs'), require('rxjs/operators')) : |
| typeof define === 'function' && define.amd ? define('@angular/cdk/stepper', ['exports', '@angular/core', '@angular/cdk/a11y', '@angular/cdk/bidi', '@angular/cdk/coercion', '@angular/cdk/keycodes', '@angular/common', 'rxjs', 'rxjs/operators'], factory) : |
| (factory((global.ng = global.ng || {}, global.ng.cdk = global.ng.cdk || {}, global.ng.cdk.stepper = {}),global.ng.core,global.ng.cdk.a11y,global.ng.cdk.bidi,global.ng.cdk.coercion,global.ng.cdk.keycodes,global.ng.common,global.rxjs,global.rxjs.operators)); |
| }(this, (function (exports,core,a11y,bidi,coercion,keycodes,common,rxjs,operators) { 'use strict'; |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| var CdkStepLabel = /** @class */ (function () { |
| function CdkStepLabel(/** @docs-private */ template) { |
| this.template = template; |
| } |
| CdkStepLabel.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: '[cdkStepLabel]', |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStepLabel.ctorParameters = function () { return [ |
| { type: core.TemplateRef } |
| ]; }; |
| return CdkStepLabel; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| var CdkStepHeader = /** @class */ (function () { |
| function CdkStepHeader(_elementRef) { |
| this._elementRef = _elementRef; |
| } |
| /** Focuses the step header. */ |
| /** |
| * Focuses the step header. |
| * @return {?} |
| */ |
| CdkStepHeader.prototype.focus = /** |
| * Focuses the step header. |
| * @return {?} |
| */ |
| function () { |
| this._elementRef.nativeElement.focus(); |
| }; |
| CdkStepHeader.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: '[cdkStepHeader]', |
| host: { |
| 'role': 'tab', |
| }, |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStepHeader.ctorParameters = function () { return [ |
| { type: core.ElementRef } |
| ]; }; |
| return CdkStepHeader; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| /** |
| * Used to generate unique ID for each stepper component. |
| * @type {?} |
| */ |
| var nextId = 0; |
| /** |
| * Change event emitted on selection changes. |
| */ |
| var /** |
| * Change event emitted on selection changes. |
| */ |
| StepperSelectionEvent = /** @class */ (function () { |
| function StepperSelectionEvent() { |
| } |
| return StepperSelectionEvent; |
| }()); |
| /** |
| * Enum to represent the different states of the steps. |
| * @type {?} |
| */ |
| var STEP_STATE = { |
| NUMBER: 'number', |
| EDIT: 'edit', |
| DONE: 'done', |
| ERROR: 'error' |
| }; |
| /** |
| * InjectionToken that can be used to specify the global stepper options. |
| * @type {?} |
| */ |
| var STEPPER_GLOBAL_OPTIONS = new core.InjectionToken('STEPPER_GLOBAL_OPTIONS'); |
| /** |
| * InjectionToken that can be used to specify the global stepper options. |
| * @deprecated Use `STEPPER_GLOBAL_OPTIONS` instead. |
| * \@breaking-change 8.0.0. |
| * @type {?} |
| */ |
| var MAT_STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS; |
| var CdkStep = /** @class */ (function () { |
| /** @breaking-change 8.0.0 remove the `?` after `stepperOptions` */ |
| function CdkStep(_stepper, stepperOptions) { |
| this._stepper = _stepper; |
| /** |
| * Whether user has seen the expanded step content or not. |
| */ |
| this.interacted = false; |
| this._editable = true; |
| this._optional = false; |
| this._customCompleted = null; |
| this._customError = null; |
| this._stepperOptions = stepperOptions ? stepperOptions : {}; |
| this._displayDefaultIndicatorType = this._stepperOptions.displayDefaultIndicatorType !== false; |
| this._showError = !!this._stepperOptions.showError; |
| } |
| Object.defineProperty(CdkStep.prototype, "editable", { |
| /** Whether the user can return to this step once it has been marked as completed. */ |
| get: /** |
| * Whether the user can return to this step once it has been marked as completed. |
| * @return {?} |
| */ |
| function () { return this._editable; }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._editable = coercion.coerceBooleanProperty(value); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkStep.prototype, "optional", { |
| /** Whether the completion of step is optional. */ |
| get: /** |
| * Whether the completion of step is optional. |
| * @return {?} |
| */ |
| function () { return this._optional; }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._optional = coercion.coerceBooleanProperty(value); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkStep.prototype, "completed", { |
| /** Whether step is marked as completed. */ |
| get: /** |
| * Whether step is marked as completed. |
| * @return {?} |
| */ |
| function () { |
| return this._customCompleted == null ? this._getDefaultCompleted() : this._customCompleted; |
| }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._customCompleted = coercion.coerceBooleanProperty(value); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * @private |
| * @return {?} |
| */ |
| CdkStep.prototype._getDefaultCompleted = /** |
| * @private |
| * @return {?} |
| */ |
| function () { |
| return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted; |
| }; |
| Object.defineProperty(CdkStep.prototype, "hasError", { |
| /** Whether step has an error. */ |
| get: /** |
| * Whether step has an error. |
| * @return {?} |
| */ |
| function () { |
| return this._customError == null ? this._getDefaultError() : this._customError; |
| }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { |
| this._customError = coercion.coerceBooleanProperty(value); |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * @private |
| * @return {?} |
| */ |
| CdkStep.prototype._getDefaultError = /** |
| * @private |
| * @return {?} |
| */ |
| function () { |
| return this.stepControl && this.stepControl.invalid && this.interacted; |
| }; |
| /** Selects this step component. */ |
| /** |
| * Selects this step component. |
| * @return {?} |
| */ |
| CdkStep.prototype.select = /** |
| * Selects this step component. |
| * @return {?} |
| */ |
| function () { |
| this._stepper.selected = this; |
| }; |
| /** Resets the step to its initial state. Note that this includes resetting form data. */ |
| /** |
| * Resets the step to its initial state. Note that this includes resetting form data. |
| * @return {?} |
| */ |
| CdkStep.prototype.reset = /** |
| * Resets the step to its initial state. Note that this includes resetting form data. |
| * @return {?} |
| */ |
| function () { |
| this.interacted = false; |
| if (this._customCompleted != null) { |
| this._customCompleted = false; |
| } |
| if (this._customError != null) { |
| this._customError = false; |
| } |
| if (this.stepControl) { |
| this.stepControl.reset(); |
| } |
| }; |
| /** |
| * @return {?} |
| */ |
| CdkStep.prototype.ngOnChanges = /** |
| * @return {?} |
| */ |
| function () { |
| // 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(); |
| }; |
| CdkStep.decorators = [ |
| { type: core.Component, args: [{selector: 'cdk-step', |
| exportAs: 'cdkStep', |
| template: '<ng-template><ng-content></ng-content></ng-template>', |
| encapsulation: core.ViewEncapsulation.None, |
| changeDetection: core.ChangeDetectionStrategy.OnPush, |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStep.ctorParameters = function () { return [ |
| { type: CdkStepper, decorators: [{ type: core.Inject, args: [core.forwardRef((/** |
| * @return {?} |
| */ |
| function () { return CdkStepper; })),] }] }, |
| { type: undefined, decorators: [{ type: core.Optional }, { type: core.Inject, args: [STEPPER_GLOBAL_OPTIONS,] }] } |
| ]; }; |
| CdkStep.propDecorators = { |
| stepLabel: [{ type: core.ContentChild, args: [CdkStepLabel, { static: false },] }], |
| content: [{ type: core.ViewChild, args: [core.TemplateRef, { static: true },] }], |
| stepControl: [{ type: core.Input }], |
| label: [{ type: core.Input }], |
| errorMessage: [{ type: core.Input }], |
| ariaLabel: [{ type: core.Input, args: ['aria-label',] }], |
| ariaLabelledby: [{ type: core.Input, args: ['aria-labelledby',] }], |
| state: [{ type: core.Input }], |
| editable: [{ type: core.Input }], |
| optional: [{ type: core.Input }], |
| completed: [{ type: core.Input }], |
| hasError: [{ type: core.Input }] |
| }; |
| return CdkStep; |
| }()); |
| var CdkStepper = /** @class */ (function () { |
| function CdkStepper(_dir, _changeDetectorRef, _elementRef, _document) { |
| this._dir = _dir; |
| this._changeDetectorRef = _changeDetectorRef; |
| this._elementRef = _elementRef; |
| /** |
| * Emits when the component is destroyed. |
| */ |
| this._destroyed = new rxjs.Subject(); |
| this._linear = false; |
| this._selectedIndex = 0; |
| /** |
| * Event emitted when the selected step has changed. |
| */ |
| this.selectionChange = new core.EventEmitter(); |
| this._orientation = 'horizontal'; |
| this._groupId = nextId++; |
| this._document = _document; |
| } |
| Object.defineProperty(CdkStepper.prototype, "steps", { |
| /** The list of step components that the stepper is holding. */ |
| get: /** |
| * The list of step components that the stepper is holding. |
| * @return {?} |
| */ |
| function () { |
| return this._steps; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkStepper.prototype, "linear", { |
| /** Whether the validity of previous steps should be checked or not. */ |
| get: /** |
| * Whether the validity of previous steps should be checked or not. |
| * @return {?} |
| */ |
| function () { return this._linear; }, |
| set: /** |
| * @param {?} value |
| * @return {?} |
| */ |
| function (value) { this._linear = coercion.coerceBooleanProperty(value); }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkStepper.prototype, "selectedIndex", { |
| /** The index of the selected step. */ |
| get: /** |
| * The index of the selected step. |
| * @return {?} |
| */ |
| function () { return this._selectedIndex; }, |
| set: /** |
| * @param {?} index |
| * @return {?} |
| */ |
| function (index) { |
| /** @type {?} */ |
| var newIndex = coercion.coerceNumberProperty(index); |
| if (this.steps) { |
| // Ensure that the index can't be out of bounds. |
| if (newIndex < 0 || newIndex > this.steps.length - 1) { |
| throw Error('cdkStepper: Cannot assign out-of-bounds value to `selectedIndex`.'); |
| } |
| if (this._selectedIndex != newIndex && |
| !this._anyControlsInvalidOrPending(newIndex) && |
| (newIndex >= this._selectedIndex || this.steps.toArray()[newIndex].editable)) { |
| this._updateSelectedItemIndex(index); |
| } |
| } |
| else { |
| this._selectedIndex = newIndex; |
| } |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| Object.defineProperty(CdkStepper.prototype, "selected", { |
| /** The step that is selected. */ |
| get: /** |
| * The step that is selected. |
| * @return {?} |
| */ |
| function () { |
| // @breaking-change 8.0.0 Change return type to `CdkStep | undefined`. |
| return this.steps ? this.steps.toArray()[this.selectedIndex] : (/** @type {?} */ (undefined)); |
| }, |
| set: /** |
| * @param {?} step |
| * @return {?} |
| */ |
| function (step) { |
| this.selectedIndex = this.steps ? this.steps.toArray().indexOf(step) : -1; |
| }, |
| enumerable: true, |
| configurable: true |
| }); |
| /** |
| * @return {?} |
| */ |
| CdkStepper.prototype.ngAfterViewInit = /** |
| * @return {?} |
| */ |
| function () { |
| var _this = this; |
| // Note that while the step headers are content children by default, any components that |
| // extend this one might have them as view chidren. We initialize the keyboard handling in |
| // AfterViewInit so we're guaranteed for both view and content children to be defined. |
| this._keyManager = new a11y.FocusKeyManager(this._stepHeader) |
| .withWrap() |
| .withVerticalOrientation(this._orientation === 'vertical'); |
| (this._dir ? (/** @type {?} */ (this._dir.change)) : rxjs.of()) |
| .pipe(operators.startWith(this._layoutDirection()), operators.takeUntil(this._destroyed)) |
| .subscribe((/** |
| * @param {?} direction |
| * @return {?} |
| */ |
| function (direction) { return _this._keyManager.withHorizontalOrientation(direction); })); |
| this._keyManager.updateActiveItemIndex(this._selectedIndex); |
| this.steps.changes.pipe(operators.takeUntil(this._destroyed)).subscribe((/** |
| * @return {?} |
| */ |
| function () { |
| if (!_this.selected) { |
| _this._selectedIndex = Math.max(_this._selectedIndex - 1, 0); |
| } |
| })); |
| }; |
| /** |
| * @return {?} |
| */ |
| CdkStepper.prototype.ngOnDestroy = /** |
| * @return {?} |
| */ |
| function () { |
| this._destroyed.next(); |
| this._destroyed.complete(); |
| }; |
| /** Selects and focuses the next step in list. */ |
| /** |
| * Selects and focuses the next step in list. |
| * @return {?} |
| */ |
| CdkStepper.prototype.next = /** |
| * Selects and focuses the next step in list. |
| * @return {?} |
| */ |
| function () { |
| this.selectedIndex = Math.min(this._selectedIndex + 1, this.steps.length - 1); |
| }; |
| /** Selects and focuses the previous step in list. */ |
| /** |
| * Selects and focuses the previous step in list. |
| * @return {?} |
| */ |
| CdkStepper.prototype.previous = /** |
| * Selects and focuses the previous step in list. |
| * @return {?} |
| */ |
| function () { |
| this.selectedIndex = Math.max(this._selectedIndex - 1, 0); |
| }; |
| /** Resets the stepper to its initial state. Note that this includes clearing form data. */ |
| /** |
| * Resets the stepper to its initial state. Note that this includes clearing form data. |
| * @return {?} |
| */ |
| CdkStepper.prototype.reset = /** |
| * Resets the stepper to its initial state. Note that this includes clearing form data. |
| * @return {?} |
| */ |
| function () { |
| this._updateSelectedItemIndex(0); |
| this.steps.forEach((/** |
| * @param {?} step |
| * @return {?} |
| */ |
| function (step) { return step.reset(); })); |
| this._stateChanged(); |
| }; |
| /** Returns a unique id for each step label element. */ |
| /** |
| * Returns a unique id for each step label element. |
| * @param {?} i |
| * @return {?} |
| */ |
| CdkStepper.prototype._getStepLabelId = /** |
| * Returns a unique id for each step label element. |
| * @param {?} i |
| * @return {?} |
| */ |
| function (i) { |
| return "cdk-step-label-" + this._groupId + "-" + i; |
| }; |
| /** Returns unique id for each step content element. */ |
| /** |
| * Returns unique id for each step content element. |
| * @param {?} i |
| * @return {?} |
| */ |
| CdkStepper.prototype._getStepContentId = /** |
| * Returns unique id for each step content element. |
| * @param {?} i |
| * @return {?} |
| */ |
| function (i) { |
| return "cdk-step-content-" + this._groupId + "-" + i; |
| }; |
| /** Marks the component to be change detected. */ |
| /** |
| * Marks the component to be change detected. |
| * @return {?} |
| */ |
| CdkStepper.prototype._stateChanged = /** |
| * Marks the component to be change detected. |
| * @return {?} |
| */ |
| function () { |
| this._changeDetectorRef.markForCheck(); |
| }; |
| /** Returns position state of the step with the given index. */ |
| /** |
| * Returns position state of the step with the given index. |
| * @param {?} index |
| * @return {?} |
| */ |
| CdkStepper.prototype._getAnimationDirection = /** |
| * Returns position state of the step with the given index. |
| * @param {?} index |
| * @return {?} |
| */ |
| function (index) { |
| /** @type {?} */ |
| var 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. */ |
| /** |
| * Returns the type of icon to be displayed. |
| * @param {?} index |
| * @param {?=} state |
| * @return {?} |
| */ |
| CdkStepper.prototype._getIndicatorType = /** |
| * Returns the type of icon to be displayed. |
| * @param {?} index |
| * @param {?=} state |
| * @return {?} |
| */ |
| function (index, state) { |
| if (state === void 0) { state = STEP_STATE.NUMBER; } |
| /** @type {?} */ |
| var step = this.steps.toArray()[index]; |
| /** @type {?} */ |
| var isCurrentStep = this._isCurrentStep(index); |
| return step._displayDefaultIndicatorType |
| ? this._getDefaultIndicatorLogic(step, isCurrentStep) |
| : this._getGuidelineLogic(step, isCurrentStep, state); |
| }; |
| /** |
| * @private |
| * @param {?} step |
| * @param {?} isCurrentStep |
| * @return {?} |
| */ |
| CdkStepper.prototype._getDefaultIndicatorLogic = /** |
| * @private |
| * @param {?} step |
| * @param {?} isCurrentStep |
| * @return {?} |
| */ |
| function (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; |
| } |
| }; |
| /** |
| * @private |
| * @param {?} step |
| * @param {?} isCurrentStep |
| * @param {?=} state |
| * @return {?} |
| */ |
| CdkStepper.prototype._getGuidelineLogic = /** |
| * @private |
| * @param {?} step |
| * @param {?} isCurrentStep |
| * @param {?=} state |
| * @return {?} |
| */ |
| function (step, isCurrentStep, state) { |
| if (state === void 0) { 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; |
| } |
| }; |
| /** |
| * @private |
| * @param {?} index |
| * @return {?} |
| */ |
| CdkStepper.prototype._isCurrentStep = /** |
| * @private |
| * @param {?} index |
| * @return {?} |
| */ |
| function (index) { |
| return this._selectedIndex === index; |
| }; |
| /** Returns the index of the currently-focused step header. */ |
| /** |
| * Returns the index of the currently-focused step header. |
| * @return {?} |
| */ |
| CdkStepper.prototype._getFocusIndex = /** |
| * Returns the index of the currently-focused step header. |
| * @return {?} |
| */ |
| function () { |
| return this._keyManager ? this._keyManager.activeItemIndex : this._selectedIndex; |
| }; |
| /** |
| * @private |
| * @param {?} newIndex |
| * @return {?} |
| */ |
| CdkStepper.prototype._updateSelectedItemIndex = /** |
| * @private |
| * @param {?} newIndex |
| * @return {?} |
| */ |
| function (newIndex) { |
| /** @type {?} */ |
| var 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.updateActiveItemIndex(newIndex); |
| this._selectedIndex = newIndex; |
| this._stateChanged(); |
| }; |
| /** |
| * @param {?} event |
| * @return {?} |
| */ |
| CdkStepper.prototype._onKeydown = /** |
| * @param {?} event |
| * @return {?} |
| */ |
| function (event) { |
| /** @type {?} */ |
| var hasModifier = keycodes.hasModifierKey(event); |
| /** @type {?} */ |
| var keyCode = event.keyCode; |
| /** @type {?} */ |
| var manager = this._keyManager; |
| if (manager.activeItemIndex != null && !hasModifier && |
| (keyCode === keycodes.SPACE || keyCode === keycodes.ENTER)) { |
| this.selectedIndex = manager.activeItemIndex; |
| event.preventDefault(); |
| } |
| else if (keyCode === keycodes.HOME) { |
| manager.setFirstItemActive(); |
| event.preventDefault(); |
| } |
| else if (keyCode === keycodes.END) { |
| manager.setLastItemActive(); |
| event.preventDefault(); |
| } |
| else { |
| manager.onKeydown(event); |
| } |
| }; |
| /** |
| * @private |
| * @param {?} index |
| * @return {?} |
| */ |
| CdkStepper.prototype._anyControlsInvalidOrPending = /** |
| * @private |
| * @param {?} index |
| * @return {?} |
| */ |
| function (index) { |
| /** @type {?} */ |
| var steps = this.steps.toArray(); |
| steps[this._selectedIndex].interacted = true; |
| if (this._linear && index >= 0) { |
| return steps.slice(0, index).some((/** |
| * @param {?} step |
| * @return {?} |
| */ |
| function (step) { |
| /** @type {?} */ |
| var control = step.stepControl; |
| /** @type {?} */ |
| var isIncomplete = control ? |
| (control.invalid || control.pending || !step.interacted) : |
| !step.completed; |
| return isIncomplete && !step.optional; |
| })); |
| } |
| return false; |
| }; |
| /** |
| * @private |
| * @return {?} |
| */ |
| CdkStepper.prototype._layoutDirection = /** |
| * @private |
| * @return {?} |
| */ |
| function () { |
| return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr'; |
| }; |
| /** Checks whether the stepper contains the focused element. */ |
| /** |
| * Checks whether the stepper contains the focused element. |
| * @private |
| * @return {?} |
| */ |
| CdkStepper.prototype._containsFocus = /** |
| * Checks whether the stepper contains the focused element. |
| * @private |
| * @return {?} |
| */ |
| function () { |
| if (!this._document || !this._elementRef) { |
| return false; |
| } |
| /** @type {?} */ |
| var stepperElement = this._elementRef.nativeElement; |
| /** @type {?} */ |
| var focusedElement = this._document.activeElement; |
| return stepperElement === focusedElement || stepperElement.contains(focusedElement); |
| }; |
| CdkStepper.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: '[cdkStepper]', |
| exportAs: 'cdkStepper', |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStepper.ctorParameters = function () { return [ |
| { type: bidi.Directionality, decorators: [{ type: core.Optional }] }, |
| { type: core.ChangeDetectorRef }, |
| { type: core.ElementRef }, |
| { type: undefined, decorators: [{ type: core.Inject, args: [common.DOCUMENT,] }] } |
| ]; }; |
| CdkStepper.propDecorators = { |
| _steps: [{ type: core.ContentChildren, args: [CdkStep,] }], |
| _stepHeader: [{ type: core.ContentChildren, args: [CdkStepHeader,] }], |
| linear: [{ type: core.Input }], |
| selectedIndex: [{ type: core.Input }], |
| selected: [{ type: core.Input }], |
| selectionChange: [{ type: core.Output }] |
| }; |
| return CdkStepper; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| /** |
| * Button that moves to the next step in a stepper workflow. |
| */ |
| var CdkStepperNext = /** @class */ (function () { |
| function CdkStepperNext(_stepper) { |
| this._stepper = _stepper; |
| /** |
| * Type of the next button. Defaults to "submit" if not specified. |
| */ |
| this.type = 'submit'; |
| } |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| /** |
| * @return {?} |
| */ |
| CdkStepperNext.prototype._handleClick = |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| /** |
| * @return {?} |
| */ |
| function () { |
| this._stepper.next(); |
| }; |
| CdkStepperNext.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: 'button[cdkStepperNext]', |
| host: { |
| '[type]': 'type', |
| } |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStepperNext.ctorParameters = function () { return [ |
| { type: CdkStepper } |
| ]; }; |
| CdkStepperNext.propDecorators = { |
| type: [{ type: core.Input }], |
| _handleClick: [{ type: core.HostListener, args: ['click',] }] |
| }; |
| return CdkStepperNext; |
| }()); |
| /** |
| * Button that moves to the previous step in a stepper workflow. |
| */ |
| var CdkStepperPrevious = /** @class */ (function () { |
| function CdkStepperPrevious(_stepper) { |
| this._stepper = _stepper; |
| /** |
| * Type of the previous button. Defaults to "button" if not specified. |
| */ |
| this.type = 'button'; |
| } |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| /** |
| * @return {?} |
| */ |
| CdkStepperPrevious.prototype._handleClick = |
| // We have to use a `HostListener` here in order to support both Ivy and ViewEngine. |
| // In Ivy the `host` bindings will be merged when this class is extended, whereas in |
| // ViewEngine they're overwritte. |
| // TODO(crisbeto): we move this back into `host` once Ivy is turned on by default. |
| // tslint:disable-next-line:no-host-decorator-in-concrete |
| /** |
| * @return {?} |
| */ |
| function () { |
| this._stepper.previous(); |
| }; |
| CdkStepperPrevious.decorators = [ |
| { type: core.Directive, args: [{ |
| selector: 'button[cdkStepperPrevious]', |
| host: { |
| '[type]': 'type', |
| } |
| },] }, |
| ]; |
| /** @nocollapse */ |
| CdkStepperPrevious.ctorParameters = function () { return [ |
| { type: CdkStepper } |
| ]; }; |
| CdkStepperPrevious.propDecorators = { |
| type: [{ type: core.Input }], |
| _handleClick: [{ type: core.HostListener, args: ['click',] }] |
| }; |
| return CdkStepperPrevious; |
| }()); |
| |
| /** |
| * @fileoverview added by tsickle |
| * @suppress {checkTypes,extraRequire,missingOverride,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc |
| */ |
| var CdkStepperModule = /** @class */ (function () { |
| function CdkStepperModule() { |
| } |
| CdkStepperModule.decorators = [ |
| { type: core.NgModule, args: [{ |
| imports: [bidi.BidiModule, common.CommonModule], |
| exports: [ |
| CdkStep, |
| CdkStepper, |
| CdkStepHeader, |
| CdkStepLabel, |
| CdkStepperNext, |
| CdkStepperPrevious, |
| ], |
| declarations: [ |
| CdkStep, |
| CdkStepper, |
| CdkStepHeader, |
| CdkStepLabel, |
| CdkStepperNext, |
| CdkStepperPrevious, |
| ] |
| },] }, |
| ]; |
| return CdkStepperModule; |
| }()); |
| |
| exports.StepperSelectionEvent = StepperSelectionEvent; |
| exports.STEP_STATE = STEP_STATE; |
| exports.STEPPER_GLOBAL_OPTIONS = STEPPER_GLOBAL_OPTIONS; |
| exports.MAT_STEPPER_GLOBAL_OPTIONS = MAT_STEPPER_GLOBAL_OPTIONS; |
| exports.CdkStep = CdkStep; |
| exports.CdkStepper = CdkStepper; |
| exports.CdkStepLabel = CdkStepLabel; |
| exports.CdkStepperNext = CdkStepperNext; |
| exports.CdkStepperPrevious = CdkStepperPrevious; |
| exports.CdkStepperModule = CdkStepperModule; |
| exports.CdkStepHeader = CdkStepHeader; |
| |
| Object.defineProperty(exports, '__esModule', { value: true }); |
| |
| }))); |
| //# sourceMappingURL=cdk-stepper.umd.js.map |