http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/esm2015/scrolling.js ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/esm2015/scrolling.js b/node_modules/@angular/cdk/esm2015/scrolling.js new file mode 100644 index 0000000..99ee5f6 --- /dev/null +++ b/node_modules/@angular/cdk/esm2015/scrolling.js @@ -0,0 +1,401 @@ +/** + * @license + * Copyright Google Inc. 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 { Directive, ElementRef, Injectable, NgModule, NgZone, Optional, Renderer2, SkipSelf } from '@angular/core'; +import { Platform, PlatformModule } from '@angular/cdk/platform'; +import { Subject } from 'rxjs/Subject'; +import { Subscription } from 'rxjs/Subscription'; +import { fromEvent } from 'rxjs/observable/fromEvent'; +import { auditTime } from 'rxjs/operator/auditTime'; +import { merge } from 'rxjs/observable/merge'; +import { of } from 'rxjs/observable/of'; + +/** + * Time in ms to throttle the scrolling events by default. + */ +const DEFAULT_SCROLL_TIME = 20; +/** + * Service contained all registered Scrollable references and emits an event when any one of the + * Scrollable references emit a scrolled event. + */ +class ScrollDispatcher { + /** + * @param {?} _ngZone + * @param {?} _platform + */ + constructor(_ngZone, _platform) { + this._ngZone = _ngZone; + this._platform = _platform; + /** + * Subject for notifying that a registered scrollable reference element has been scrolled. + */ + this._scrolled = new Subject(); + /** + * Keeps track of the global `scroll` and `resize` subscriptions. + */ + this._globalSubscription = null; + /** + * Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards. + */ + this._scrolledCount = 0; + /** + * Map of all the scrollable references that are registered with the service and their + * scroll event subscriptions. + */ + this.scrollableReferences = new Map(); + } + /** + * Registers a Scrollable with the service and listens for its scrolled events. When the + * scrollable is scrolled, the service emits the event in its scrolled observable. + * @param {?} scrollable Scrollable instance to be registered. + * @return {?} + */ + register(scrollable) { + const /** @type {?} */ scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify()); + this.scrollableReferences.set(scrollable, scrollSubscription); + } + /** + * Deregisters a Scrollable reference and unsubscribes from its scroll event observable. + * @param {?} scrollable Scrollable instance to be deregistered. + * @return {?} + */ + deregister(scrollable) { + const /** @type {?} */ scrollableReference = this.scrollableReferences.get(scrollable); + if (scrollableReference) { + scrollableReference.unsubscribe(); + this.scrollableReferences.delete(scrollable); + } + } + /** + * Subscribes to an observable that emits an event whenever any of the registered Scrollable + * references (or window, document, or body) fire a scrolled event. Can provide a time in ms + * to override the default "throttle" time. + * @param {?=} auditTimeInMs + * @param {?=} callback + * @return {?} + */ + scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME, callback) { + // Scroll events can only happen on the browser, so do nothing if we're not on the browser. + if (!this._platform.isBrowser) { + return Subscription.EMPTY; + } + // In the case of a 0ms delay, use an observable without auditTime + // since it does add a perceptible delay in processing overhead. + let /** @type {?} */ observable = auditTimeInMs > 0 ? + auditTime.call(this._scrolled.asObservable(), auditTimeInMs) : + this._scrolled.asObservable(); + this._scrolledCount++; + if (!this._globalSubscription) { + this._globalSubscription = this._ngZone.runOutsideAngular(() => { + return fromEvent(window.document, 'scroll').subscribe(() => this._notify()); + }); + } + // Note that we need to do the subscribing from here, in order to be able to remove + // the global event listeners once there are no more subscriptions. + let /** @type {?} */ subscription = observable.subscribe(callback); + subscription.add(() => { + this._scrolledCount--; + if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) { + this._globalSubscription.unsubscribe(); + this._globalSubscription = null; + } + }); + return subscription; + } + /** + * Returns all registered Scrollables that contain the provided element. + * @param {?} elementRef + * @return {?} + */ + getScrollContainers(elementRef) { + const /** @type {?} */ scrollingContainers = []; + this.scrollableReferences.forEach((_subscription, scrollable) => { + if (this.scrollableContainsElement(scrollable, elementRef)) { + scrollingContainers.push(scrollable); + } + }); + return scrollingContainers; + } + /** + * Returns true if the element is contained within the provided Scrollable. + * @param {?} scrollable + * @param {?} elementRef + * @return {?} + */ + scrollableContainsElement(scrollable, elementRef) { + let /** @type {?} */ element = elementRef.nativeElement; + let /** @type {?} */ scrollableElement = scrollable.getElementRef().nativeElement; + // Traverse through the element parents until we reach null, checking if any of the elements + // are the scrollable's element. + do { + if (element == scrollableElement) { + return true; + } + } while (element = element.parentElement); + return false; + } + /** + * Sends a notification that a scroll event has been fired. + * @return {?} + */ + _notify() { + this._scrolled.next(); + } +} +ScrollDispatcher.decorators = [ + { type: Injectable }, +]; +/** + * @nocollapse + */ +ScrollDispatcher.ctorParameters = () => [ + { type: NgZone, }, + { type: Platform, }, +]; +/** + * \@docs-private + * @param {?} parentDispatcher + * @param {?} ngZone + * @param {?} platform + * @return {?} + */ +function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) { + return parentDispatcher || new ScrollDispatcher(ngZone, platform); +} +/** + * \@docs-private + */ +const SCROLL_DISPATCHER_PROVIDER = { + // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one. + provide: ScrollDispatcher, + deps: [[new Optional(), new SkipSelf(), ScrollDispatcher], NgZone, Platform], + useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY +}; + +/** + * Sends an event when the directive's element is scrolled. Registers itself with the + * ScrollDispatcher service to include itself as part of its collection of scrolling events that it + * can be listened to through the service. + */ +class Scrollable { + /** + * @param {?} _elementRef + * @param {?} _scroll + * @param {?} _ngZone + * @param {?} _renderer + */ + constructor(_elementRef, _scroll, _ngZone, _renderer) { + this._elementRef = _elementRef; + this._scroll = _scroll; + this._ngZone = _ngZone; + this._renderer = _renderer; + this._elementScrolled = new Subject(); + } + /** + * @return {?} + */ + ngOnInit() { + this._scrollListener = this._ngZone.runOutsideAngular(() => { + return this._renderer.listen(this.getElementRef().nativeElement, 'scroll', (event) => { + this._elementScrolled.next(event); + }); + }); + this._scroll.register(this); + } + /** + * @return {?} + */ + ngOnDestroy() { + this._scroll.deregister(this); + if (this._scrollListener) { + this._scrollListener(); + this._scrollListener = null; + } + } + /** + * Returns observable that emits when a scroll event is fired on the host element. + * @return {?} + */ + elementScrolled() { + return this._elementScrolled.asObservable(); + } + /** + * @return {?} + */ + getElementRef() { + return this._elementRef; + } +} +Scrollable.decorators = [ + { type: Directive, args: [{ + selector: '[cdk-scrollable], [cdkScrollable]' + },] }, +]; +/** + * @nocollapse + */ +Scrollable.ctorParameters = () => [ + { type: ElementRef, }, + { type: ScrollDispatcher, }, + { type: NgZone, }, + { type: Renderer2, }, +]; + +/** + * Time in ms to throttle the resize events by default. + */ +const DEFAULT_RESIZE_TIME = 20; +/** + * Simple utility for getting the bounds of the browser viewport. + * \@docs-private + */ +class ViewportRuler { + /** + * @param {?} platform + * @param {?} ngZone + * @param {?} scrollDispatcher + */ + constructor(platform, ngZone, scrollDispatcher) { + this._change = platform.isBrowser ? ngZone.runOutsideAngular(() => { + return merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange')); + }) : of(); + // Subscribe to scroll and resize events and update the document rectangle on changes. + this._invalidateCacheSubscriptions = [ + scrollDispatcher.scrolled(0, () => this._cacheViewportGeometry()), + this.change().subscribe(() => this._cacheViewportGeometry()) + ]; + } + /** + * @return {?} + */ + ngOnDestroy() { + this._invalidateCacheSubscriptions.forEach(subscription => subscription.unsubscribe()); + } + /** + * Gets a ClientRect for the viewport's bounds. + * @param {?=} documentRect + * @return {?} + */ + getViewportRect(documentRect = this._documentRect) { + // Cache the document bounding rect so that we don't recompute it for multiple calls. + if (!documentRect) { + this._cacheViewportGeometry(); + documentRect = this._documentRect; + } + // Use the document element's bounding rect rather than the window scroll properties + // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll + // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different + // conceptual viewports. Under most circumstances these viewports are equivalent, but they + // can disagree when the page is pinch-zoomed (on devices that support touch). + // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4 + // We use the documentElement instead of the body because, by default (without a css reset) + // browsers typically give the document body an 8px margin, which is not included in + // getBoundingClientRect(). + const /** @type {?} */ scrollPosition = this.getViewportScrollPosition(documentRect); + const /** @type {?} */ height = window.innerHeight; + const /** @type {?} */ width = window.innerWidth; + return { + top: scrollPosition.top, + left: scrollPosition.left, + bottom: scrollPosition.top + height, + right: scrollPosition.left + width, + height, + width, + }; + } + /** + * Gets the (top, left) scroll position of the viewport. + * @param {?=} documentRect + * @return {?} + */ + getViewportScrollPosition(documentRect = this._documentRect) { + // Cache the document bounding rect so that we don't recompute it for multiple calls. + if (!documentRect) { + this._cacheViewportGeometry(); + documentRect = this._documentRect; + } + // The top-left-corner of the viewport is determined by the scroll position of the document + // body, normally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about + // whether `document.body` or `document.documentElement` is the scrolled element, so reading + // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of + // `document.documentElement` works consistently, where the `top` and `left` values will + // equal negative the scroll position. + const /** @type {?} */ top = -((documentRect)).top || document.body.scrollTop || window.scrollY || + document.documentElement.scrollTop || 0; + const /** @type {?} */ left = -((documentRect)).left || document.body.scrollLeft || window.scrollX || + document.documentElement.scrollLeft || 0; + return { top, left }; + } + /** + * Returns a stream that emits whenever the size of the viewport changes. + * @param {?=} throttleTime + * @return {?} + */ + change(throttleTime = DEFAULT_RESIZE_TIME) { + return throttleTime > 0 ? auditTime.call(this._change, throttleTime) : this._change; + } + /** + * Caches the latest client rectangle of the document element. + * @return {?} + */ + _cacheViewportGeometry() { + this._documentRect = document.documentElement.getBoundingClientRect(); + } +} +ViewportRuler.decorators = [ + { type: Injectable }, +]; +/** + * @nocollapse + */ +ViewportRuler.ctorParameters = () => [ + { type: Platform, }, + { type: NgZone, }, + { type: ScrollDispatcher, }, +]; +/** + * \@docs-private + * @param {?} parentRuler + * @param {?} platform + * @param {?} ngZone + * @param {?} scrollDispatcher + * @return {?} + */ +function VIEWPORT_RULER_PROVIDER_FACTORY(parentRuler, platform, ngZone, scrollDispatcher) { + return parentRuler || new ViewportRuler(platform, ngZone, scrollDispatcher); +} +/** + * \@docs-private + */ +const VIEWPORT_RULER_PROVIDER = { + // If there is already a ViewportRuler available, use that. Otherwise, provide a new one. + provide: ViewportRuler, + deps: [[new Optional(), new SkipSelf(), ViewportRuler], Platform, NgZone, ScrollDispatcher], + useFactory: VIEWPORT_RULER_PROVIDER_FACTORY +}; + +class ScrollDispatchModule { +} +ScrollDispatchModule.decorators = [ + { type: NgModule, args: [{ + imports: [PlatformModule], + exports: [Scrollable], + declarations: [Scrollable], + providers: [SCROLL_DISPATCHER_PROVIDER], + },] }, +]; +/** + * @nocollapse + */ +ScrollDispatchModule.ctorParameters = () => []; + +/** + * Generated bundle index. Do not edit. + */ + +export { DEFAULT_SCROLL_TIME, ScrollDispatcher, SCROLL_DISPATCHER_PROVIDER_FACTORY, SCROLL_DISPATCHER_PROVIDER, Scrollable, DEFAULT_RESIZE_TIME, ViewportRuler, VIEWPORT_RULER_PROVIDER_FACTORY, VIEWPORT_RULER_PROVIDER, ScrollDispatchModule }; +//# sourceMappingURL=scrolling.js.map
http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/esm2015/scrolling.js.map ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/esm2015/scrolling.js.map b/node_modules/@angular/cdk/esm2015/scrolling.js.map new file mode 100644 index 0000000..b8ad538 --- /dev/null +++ b/node_modules/@angular/cdk/esm2015/scrolling.js.map @@ -0,0 +1 @@ +{"version":3,"file":"scrolling.js","sources":["../../packages/cdk/scrolling/scroll-dispatcher.js","../../packages/cdk/scrolling/scrollable.js","../../packages/cdk/scrolling/viewport-ruler.js","../../packages/cdk/scrolling/scrolling-module.js","../../packages/cdk/scrolling/index.js"],"sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 */\nimport { Injectable, NgZone, Optional, SkipSelf } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\nimport { Subject } from 'rxjs/Subject';\nimport { Subscription } from 'rxjs/Subscription';\nimport { fromEvent } from 'rxjs/observable/fromEvent';\nimport { auditTime } from 'rxjs/operator/auditTime';\n/**\n * Time in ms to throttle the scrolling events by default.\n */\nexport const DEFAULT_SCROLL_TIME = 20;\n/**\n * Service contained all registered Scrolla ble references and emits an event when any one of the\n * Scrollable references emit a scrolled event.\n */\nexport class ScrollDispatcher {\n /**\n * @param {?} _ngZone\n * @param {?} _platform\n */\n constructor(_ngZone, _platform) {\n this._ngZone = _ngZone;\n this._platform = _platform;\n /**\n * Subject for notifying that a registered scrollable reference element has been scrolled.\n */\n this._scrolled = new Subject();\n /**\n * Keeps track of the global `scroll` and `resize` subscriptions.\n */\n this._globalSubscription = null;\n /**\n * Keeps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards.\n */\n this._scrolledCount = 0;\n /**\n * Map of all the scrollable references that are registered with the service and their\n * scroll event subscriptions.\n */\n this.scrollableReferences = n ew Map();\n }\n /**\n * Registers a Scrollable with the service and listens for its scrolled events. When the\n * scrollable is scrolled, the service emits the event in its scrolled observable.\n * @param {?} scrollable Scrollable instance to be registered.\n * @return {?}\n */\n register(scrollable) {\n const /** @type {?} */ scrollSubscription = scrollable.elementScrolled().subscribe(() => this._notify());\n this.scrollableReferences.set(scrollable, scrollSubscription);\n }\n /**\n * Deregisters a Scrollable reference and unsubscribes from its scroll event observable.\n * @param {?} scrollable Scrollable instance to be deregistered.\n * @return {?}\n */\n deregister(scrollable) {\n const /** @type {?} */ scrollableReference = this.scrollableReferences.get(scrollable);\n if (scrollableReference) {\n scrollableReference.unsubscribe();\n this.scrollableReferences.delete(scrollable) ;\n }\n }\n /**\n * Subscribes to an observable that emits an event whenever any of the registered Scrollable\n * references (or window, document, or body) fire a scrolled event. Can provide a time in ms\n * to override the default \"throttle\" time.\n * @param {?=} auditTimeInMs\n * @param {?=} callback\n * @return {?}\n */\n scrolled(auditTimeInMs = DEFAULT_SCROLL_TIME, callback) {\n // Scroll events can only happen on the browser, so do nothing if we're not on the browser.\n if (!this._platform.isBrowser) {\n return Subscription.EMPTY;\n }\n // In the case of a 0ms delay, use an observable without auditTime\n // since it does add a perceptible delay in processing overhead.\n let /** @type {?} */ observable = auditTimeInMs > 0 ?\n auditTime.call(this._scrolled.asObservable(), auditTimeInMs) :\n this._scrolled.asObservable();\n this._scrolledCount++;\n if (!this._globalSubscription) {\n this._globalSubscription = this._ngZone.runOutsideAngular(() => {\n return fromEvent(window.document, 'scroll').subscribe(() => this._notify());\n });\n }\n // Note that we need to do the subscribing from here, in order to be able to remove\n // the global event listeners once there are no more subscriptions.\n let /** @type {?} */ subscription = observable.subscribe(callback);\n subscription.add(() => {\n this._scrolledCount--;\n if (this._globalSubscription && !this.scrollableReferences.size && !this._scrolledCount) {\n this._globalSubscription.unsubscribe();\n this._globalSubscription = null;\n }\n });\n return subscription;\n }\n /**\n * Returns all registered Scrollables that contain the provided element.\n * @param {?} elementRef\n * @return {?}\n */\n getScrollContaine rs(elementRef) {\n const /** @type {?} */ scrollingContainers = [];\n this.scrollableReferences.forEach((_subscription, scrollable) => {\n if (this.scrollableContainsElement(scrollable, elementRef)) {\n scrollingContainers.push(scrollable);\n }\n });\n return scrollingContainers;\n }\n /**\n * Returns true if the element is contained within the provided Scrollable.\n * @param {?} scrollable\n * @param {?} elementRef\n * @return {?}\n */\n scrollableContainsElement(scrollable, elementRef) {\n let /** @type {?} */ element = elementRef.nativeElement;\n let /** @type {?} */ scrollableElement = scrollable.getElementRef().nativeElement;\n // Traverse through the element parents until we reach null, checking if any of the elements\n // are the scrollable's element.\n do {\n if (element == scrollableElement) {\n return true;\n }\n } while (element = element.parentElement);\n return false;\n }\n /**\n * Sends a notification that a scroll event has been fired.\n * @return {?}\n */\n _notify() {\n this._scrolled.next();\n }\n}\nScrollDispatcher.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nScrollDispatcher.ctorParameters = () => [\n { type: NgZone, },\n { type: Platform, },\n];\nfunction ScrollDispatcher_tsickle_Closure_declarations() {\n /** @type {?} */\n ScrollDispatcher.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n ScrollDispatcher.ctorParameters;\n /**\n * Subject for notifying that a registered scrollable reference element has been scrolled.\n * @type {?}\n */\n ScrollDispatcher.prototype._scrolled;\n /**\n * Keeps track of the global `scroll` and `resize` subscriptions.\n * @type {?}\n */\n ScrollDispatcher.prototype._globalSubscription;\n /**\n * Ke eps track of the amount of subscriptions to `scrolled`. Used for cleaning up afterwards.\n * @type {?}\n */\n ScrollDispatcher.prototype._scrolledCount;\n /**\n * Map of all the scrollable references that are registered with the service and their\n * scroll event subscriptions.\n * @type {?}\n */\n ScrollDispatcher.prototype.scrollableReferences;\n /** @type {?} */\n ScrollDispatcher.prototype._ngZone;\n /** @type {?} */\n ScrollDispatcher.prototype._platform;\n}\n/**\n * \\@docs-private\n * @param {?} parentDispatcher\n * @param {?} ngZone\n * @param {?} platform\n * @return {?}\n */\nexport function SCROLL_DISPATCHER_PROVIDER_FACTORY(parentDispatcher, ngZone, platform) {\n return parentDispatcher || new ScrollDispatcher(ngZone, platform);\n}\n/**\n * \\@docs-private\n */\nexport const SCROLL_DISPATCHER_PROVIDER = {\n // If there is already a ScrollDispatcher available, use that. Otherwise, provide a new one.\n provide: ScrollDi spatcher,\n deps: [[new Optional(), new SkipSelf(), ScrollDispatcher], NgZone, Platform],\n useFactory: SCROLL_DISPATCHER_PROVIDER_FACTORY\n};\n//# sourceMappingURL=scroll-dispatcher.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { Directive, ElementRef, NgZone, Renderer2 } from '@angular/core';\nimport { Subject } from 'rxjs/Subject';\nimport { ScrollDispatcher } from './scroll-dispatcher';\n/**\n * Sends an event when the directive's element is scrolled. Registers itself with the\n * ScrollDispatcher service to include itself as part of its collection of scrolling events that it\n * can be listened to through the service.\n */\nexport class Scrollable {\n /**\n * @param {?} _elementRef\n * @param {?} _scroll\n * @param {?} _ngZone\n * @param {?} _renderer\n */\n constructor (_elementRef, _scroll, _ngZone, _renderer) {\n this._elementRef = _elementRef;\n this._scroll = _scroll;\n this._ngZone = _ngZone;\n this._renderer = _renderer;\n this._elementScrolled = new Subject();\n }\n /**\n * @return {?}\n */\n ngOnInit() {\n this._scrollListener = this._ngZone.runOutsideAngular(() => {\n return this._renderer.listen(this.getElementRef().nativeElement, 'scroll', (event) => {\n this._elementScrolled.next(event);\n });\n });\n this._scroll.register(this);\n }\n /**\n * @return {?}\n */\n ngOnDestroy() {\n this._scroll.deregister(this);\n if (this._scrollListener) {\n this._scrollListener();\n this._scrollListener = null;\n }\n }\n /**\n * Returns observable that emits when a scroll event is fired on the host element.\n * @return {?}\n */\n elementScrolled() {\n retur n this._elementScrolled.asObservable();\n }\n /**\n * @return {?}\n */\n getElementRef() {\n return this._elementRef;\n }\n}\nScrollable.decorators = [\n { type: Directive, args: [{\n selector: '[cdk-scrollable], [cdkScrollable]'\n },] },\n];\n/**\n * @nocollapse\n */\nScrollable.ctorParameters = () => [\n { type: ElementRef, },\n { type: ScrollDispatcher, },\n { type: NgZone, },\n { type: Renderer2, },\n];\nfunction Scrollable_tsickle_Closure_declarations() {\n /** @type {?} */\n Scrollable.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n Scrollable.ctorParameters;\n /** @type {?} */\n Scrollable.prototype._elementScrolled;\n /** @type {?} */\n Scrollable.prototype._scrollListener;\n /** @type {?} */\n Scrollable.prototype._elementRef;\n /** @type {?} */\n Scrollable.prototype._scroll;\n /** @type {?} */\n Scrollable.prototype._ngZone;\n /** @type {?} * /\n Scrollable.prototype._renderer;\n}\n//# sourceMappingURL=scrollable.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { Injectable, Optional, SkipSelf, NgZone } from '@angular/core';\nimport { Platform } from '@angular/cdk/platform';\nimport { ScrollDispatcher } from './scroll-dispatcher';\nimport { fromEvent } from 'rxjs/observable/fromEvent';\nimport { merge } from 'rxjs/observable/merge';\nimport { auditTime } from 'rxjs/operator/auditTime';\nimport { of as observableOf } from 'rxjs/observable/of';\n/**\n * Time in ms to throttle the resize events by default.\n */\nexport const DEFAULT_RESIZE_TIME = 20;\n/**\n * Simple utility for getting the bounds of the browser viewport.\n * \\@docs-private\n */\nexport class ViewportRuler {\n /**\n * @param {?} platform\n * @param {?} ngZone\n * @p aram {?} scrollDispatcher\n */\n constructor(platform, ngZone, scrollDispatcher) {\n this._change = platform.isBrowser ? ngZone.runOutsideAngular(() => {\n return merge(fromEvent(window, 'resize'), fromEvent(window, 'orientationchange'));\n }) : observableOf();\n // Subscribe to scroll and resize events and update the document rectangle on changes.\n this._invalidateCacheSubscriptions = [\n scrollDispatcher.scrolled(0, () => this._cacheViewportGeometry()),\n this.change().subscribe(() => this._cacheViewportGeometry())\n ];\n }\n /**\n * @return {?}\n */\n ngOnDestroy() {\n this._invalidateCacheSubscriptions.forEach(subscription => subscription.unsubscribe());\n }\n /**\n * Gets a ClientRect for the viewport's bounds.\n * @param {?=} documentRect\n * @return {?}\n */\n getViewportRect(documentRect = this._documentRect) {\n // Cache the document bounding r ect so that we don't recompute it for multiple calls.\n if (!documentRect) {\n this._cacheViewportGeometry();\n documentRect = this._documentRect;\n }\n // Use the document element's bounding rect rather than the window scroll properties\n // (e.g. pageYOffset, scrollY) due to in issue in Chrome and IE where window scroll\n // properties and client coordinates (boundingClientRect, clientX/Y, etc.) are in different\n // conceptual viewports. Under most circumstances these viewports are equivalent, but they\n // can disagree when the page is pinch-zoomed (on devices that support touch).\n // See https://bugs.chromium.org/p/chromium/issues/detail?id=489206#c4\n // We use the documentElement instead of the body because, by default (without a css reset)\n // browsers typically give the document body an 8px margin, which is not included in\n // getBoundingClientRect().\n const /** @ty pe {?} */ scrollPosition = this.getViewportScrollPosition(documentRect);\n const /** @type {?} */ height = window.innerHeight;\n const /** @type {?} */ width = window.innerWidth;\n return {\n top: scrollPosition.top,\n left: scrollPosition.left,\n bottom: scrollPosition.top + height,\n right: scrollPosition.left + width,\n height,\n width,\n };\n }\n /**\n * Gets the (top, left) scroll position of the viewport.\n * @param {?=} documentRect\n * @return {?}\n */\n getViewportScrollPosition(documentRect = this._documentRect) {\n // Cache the document bounding rect so that we don't recompute it for multiple calls.\n if (!documentRect) {\n this._cacheViewportGeometry();\n documentRect = this._documentRect;\n }\n // The top-left-corner of the viewport is determined by the scroll position of the document\n // body, n ormally just (scrollLeft, scrollTop). However, Chrome and Firefox disagree about\n // whether `document.body` or `document.documentElement` is the scrolled element, so reading\n // `scrollTop` and `scrollLeft` is inconsistent. However, using the bounding rect of\n // `document.documentElement` works consistently, where the `top` and `left` values will\n // equal negative the scroll position.\n const /** @type {?} */ top = -((documentRect)).top || document.body.scrollTop || window.scrollY ||\n document.documentElement.scrollTop || 0;\n const /** @type {?} */ left = -((documentRect)).left || document.body.scrollLeft || window.scrollX ||\n document.documentElement.scrollLeft || 0;\n return { top, left };\n }\n /**\n * Returns a stream that emits whenever the size of the viewport changes.\n * @param {?=} throttleTime\n * @return {?}\n */\n change(throttleTime = DEFAULT_RESIZE_TIME) {\n return throttleTime > 0 ? auditTime.call(this._change, throttleTime) : this._change;\n }\n /**\n * Caches the latest client rectangle of the document element.\n * @return {?}\n */\n _cacheViewportGeometry() {\n this._documentRect = document.documentElement.getBoundingClientRect();\n }\n}\nViewportRuler.decorators = [\n { type: Injectable },\n];\n/**\n * @nocollapse\n */\nViewportRuler.ctorParameters = () => [\n { type: Platform, },\n { type: NgZone, },\n { type: ScrollDispatcher, },\n];\nfunction ViewportRuler_tsickle_Closure_declarations() {\n /** @type {?} */\n ViewportRuler.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n ViewportRuler.ctorParameters;\n /**\n * Cached document client rectangle.\n * @type {?}\n */\n ViewportRuler.prototype._documentRect;\n /**\n * Stream of viewport change events.\n * @type {?}\n */\n ViewportRuler.prototype._change;\n /**\n * Subsc riptions to streams that invalidate the cached viewport dimensions.\n * @type {?}\n */\n ViewportRuler.prototype._invalidateCacheSubscriptions;\n}\n/**\n * \\@docs-private\n * @param {?} parentRuler\n * @param {?} platform\n * @param {?} ngZone\n * @param {?} scrollDispatcher\n * @return {?}\n */\nexport function VIEWPORT_RULER_PROVIDER_FACTORY(parentRuler, platform, ngZone, scrollDispatcher) {\n return parentRuler || new ViewportRuler(platform, ngZone, scrollDispatcher);\n}\n/**\n * \\@docs-private\n */\nexport const VIEWPORT_RULER_PROVIDER = {\n // If there is already a ViewportRuler available, use that. Otherwise, provide a new one.\n provide: ViewportRuler,\n deps: [[new Optional(), new SkipSelf(), ViewportRuler], Platform, NgZone, ScrollDispatcher],\n useFactory: VIEWPORT_RULER_PROVIDER_FACTORY\n};\n//# sourceMappingURL=viewport-ruler.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { NgModule } from '@angular/core';\nimport { SCROLL_DISPATCHER_PROVIDER } from './scroll-dispatcher';\nimport { Scrollable } from './scrollable';\nimport { PlatformModule } from '@angular/cdk/platform';\nexport class ScrollDispatchModule {\n}\nScrollDispatchModule.decorators = [\n { type: NgModule, args: [{\n imports: [PlatformModule],\n exports: [Scrollable],\n declarations: [Scrollable],\n providers: [SCROLL_DISPATCHER_PROVIDER],\n },] },\n];\n/**\n * @nocollapse\n */\nScrollDispatchModule.ctorParameters = () => [];\nfunction ScrollDispatchModule_tsickle_Closure_declarations() {\n /** @type {?} */\n ScrollDispatchModule.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n ScrollDispatchModule.ctorParameters;\n}\n//# sourceMappingURL=scrolling-module.js.map","/**\n * Generated b undle index. Do not edit.\n */\nexport { DEFAULT_SCROLL_TIME, ScrollDispatcher, SCROLL_DISPATCHER_PROVIDER_FACTORY, SCROLL_DISPATCHER_PROVIDER, Scrollable, DEFAULT_RESIZE_TIME, ViewportRuler, VIEWPORT_RULER_PROVIDER_FACTORY, VIEWPORT_RULER_PROVIDER, ScrollDispatchModule } from './public-api';\n//# sourceMappingURL=index.js.map"],"names":["observableOf"],"mappings":"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"} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/esm2015/stepper.js ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/esm2015/stepper.js b/node_modules/@angular/cdk/esm2015/stepper.js new file mode 100644 index 0000000..708ef7c --- /dev/null +++ b/node_modules/@angular/cdk/esm2015/stepper.js @@ -0,0 +1,440 @@ +/** + * @license + * Copyright Google Inc. 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 { ChangeDetectionStrategy, ChangeDetectorRef, Component, ContentChild, ContentChildren, Directive, EventEmitter, Inject, Input, NgModule, Optional, Output, TemplateRef, ViewChild, ViewEncapsulation, forwardRef } from '@angular/core'; +import { ENTER, LEFT_ARROW, RIGHT_ARROW, SPACE } from '@angular/cdk/keycodes'; +import { coerceBooleanProperty } from '@angular/cdk/coercion'; +import { BidiModule, Directionality } from '@angular/cdk/bidi'; +import { CommonModule } from '@angular/common'; + +class CdkStepLabel { + /** + * @param {?} template + */ + constructor(template) { + this.template = template; + } +} +CdkStepLabel.decorators = [ + { type: Directive, args: [{ + selector: '[cdkStepLabel]', + },] }, +]; +/** + * @nocollapse + */ +CdkStepLabel.ctorParameters = () => [ + { type: TemplateRef, }, +]; + +/** + * Used to generate unique ID for each stepper component. + */ +let nextId = 0; +/** + * Change event emitted on selection changes. + */ +class StepperSelectionEvent { +} +class CdkStep { + /** + * @param {?} _stepper + */ + constructor(_stepper) { + 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; + } + /** + * @return {?} + */ + get editable() { return this._editable; } + /** + * @param {?} value + * @return {?} + */ + set editable(value) { + this._editable = coerceBooleanProperty(value); + } + /** + * Whether the completion of step is optional or not. + * @return {?} + */ + get optional() { return this._optional; } + /** + * @param {?} value + * @return {?} + */ + set optional(value) { + this._optional = coerceBooleanProperty(value); + } + /** + * Return whether step is completed or not. + * @return {?} + */ + get completed() { + return this._customCompleted == null ? this._defaultCompleted : this._customCompleted; + } + /** + * @param {?} value + * @return {?} + */ + set completed(value) { + this._customCompleted = coerceBooleanProperty(value); + } + /** + * @return {?} + */ + get _defaultCompleted() { + return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted; + } + /** + * Selects this step component. + * @return {?} + */ + select() { + this._stepper.selected = this; + } + /** + * @return {?} + */ + ngOnChanges() { + // Since basically all inputs of the MdStep get proxied through the view down to the + // underlying MdStepHeader, we have to make sure that change detection runs correctly. + this._stepper._stateChanged(); + } +} +CdkStep.decorators = [ + { type: Component, args: [{selector: 'cdk-step', + exportAs: 'cdkStep', + template: "<ng-template><ng-content></ng-content></ng-template>", + encapsulation: ViewEncapsulation.None, + preserveWhitespaces: false, + changeDetection: ChangeDetectionStrategy.OnPush, + },] }, +]; +/** + * @nocollapse + */ +CdkStep.ctorParameters = () => [ + { type: CdkStepper, decorators: [{ type: Inject, args: [forwardRef(() => CdkStepper),] },] }, +]; +CdkStep.propDecorators = { + 'stepLabel': [{ type: ContentChild, args: [CdkStepLabel,] },], + 'content': [{ type: ViewChild, args: [TemplateRef,] },], + 'stepControl': [{ type: Input },], + 'label': [{ type: Input },], + 'editable': [{ type: Input },], + 'optional': [{ type: Input },], + 'completed': [{ type: Input },], +}; +class CdkStepper { + /** + * @param {?} _dir + * @param {?} _changeDetectorRef + */ + constructor(_dir, _changeDetectorRef) { + this._dir = _dir; + this._changeDetectorRef = _changeDetectorRef; + this._linear = false; + this._selectedIndex = 0; + /** + * Event emitted when the selected step has changed. + */ + this.selectionChange = new EventEmitter(); + /** + * The index of the step that the focus can be set. + */ + this._focusIndex = 0; + this._groupId = nextId++; + } + /** + * Whether the validity of previous steps should be checked or not. + * @return {?} + */ + get linear() { return this._linear; } + /** + * @param {?} value + * @return {?} + */ + set linear(value) { this._linear = coerceBooleanProperty(value); } + /** + * The index of the selected step. + * @return {?} + */ + get selectedIndex() { return this._selectedIndex; } + /** + * @param {?} index + * @return {?} + */ + set selectedIndex(index) { + if (this._anyControlsInvalid(index) + || index < this._selectedIndex && !this._steps.toArray()[index].editable) { + // remove focus from clicked step header if the step is not able to be selected + this._stepHeader.toArray()[index].nativeElement.blur(); + } + else if (this._selectedIndex != index) { + this._emitStepperSelectionEvent(index); + this._focusIndex = this._selectedIndex; + } + } + /** + * The step that is selected. + * @return {?} + */ + get selected() { return this._steps.toArray()[this.selectedIndex]; } + /** + * @param {?} step + * @return {?} + */ + set selected(step) { + this.selectedIndex = this._steps.toArray().indexOf(step); + } + /** + * Selects and focuses the next step in list. + * @return {?} + */ + next() { + this.selectedIndex = Math.min(this._selectedIndex + 1, this._steps.length - 1); + } + /** + * Selects and focuses the previous step in list. + * @return {?} + */ + previous() { + this.selectedIndex = Math.max(this._selectedIndex - 1, 0); + } + /** + * Returns a unique id for each step label element. + * @param {?} i + * @return {?} + */ + _getStepLabelId(i) { + return `mat-step-label-${this._groupId}-${i}`; + } + /** + * Returns unique id for each step content element. + * @param {?} i + * @return {?} + */ + _getStepContentId(i) { + return `mat-step-content-${this._groupId}-${i}`; + } + /** + * Marks the component to be change detected. + * @return {?} + */ + _stateChanged() { + this._changeDetectorRef.markForCheck(); + } + /** + * Returns position state of the step with the given index. + * @param {?} index + * @return {?} + */ + _getAnimationDirection(index) { + const /** @type {?} */ 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. + * @param {?} index + * @return {?} + */ + _getIndicatorType(index) { + const /** @type {?} */ step = this._steps.toArray()[index]; + if (!step.completed || this._selectedIndex == index) { + return 'number'; + } + else { + return step.editable ? 'edit' : 'done'; + } + } + /** + * @param {?} newIndex + * @return {?} + */ + _emitStepperSelectionEvent(newIndex) { + const /** @type {?} */ stepsArray = this._steps.toArray(); + this.selectionChange.emit({ + selectedIndex: newIndex, + previouslySelectedIndex: this._selectedIndex, + selectedStep: stepsArray[newIndex], + previouslySelectedStep: stepsArray[this._selectedIndex], + }); + this._selectedIndex = newIndex; + this._stateChanged(); + } + /** + * @param {?} event + * @return {?} + */ + _onKeydown(event) { + switch (event.keyCode) { + case RIGHT_ARROW: + if (this._layoutDirection() === 'rtl') { + this._focusPreviousStep(); + } + else { + this._focusNextStep(); + } + break; + case LEFT_ARROW: + if (this._layoutDirection() === 'rtl') { + this._focusNextStep(); + } + else { + this._focusPreviousStep(); + } + break; + case SPACE: + case ENTER: + this.selectedIndex = this._focusIndex; + break; + default: + // Return to avoid calling preventDefault on keys that are not explicitly handled. + return; + } + event.preventDefault(); + } + /** + * @return {?} + */ + _focusNextStep() { + this._focusStep((this._focusIndex + 1) % this._steps.length); + } + /** + * @return {?} + */ + _focusPreviousStep() { + this._focusStep((this._focusIndex + this._steps.length - 1) % this._steps.length); + } + /** + * @param {?} index + * @return {?} + */ + _focusStep(index) { + this._focusIndex = index; + this._stepHeader.toArray()[this._focusIndex].nativeElement.focus(); + } + /** + * @param {?} index + * @return {?} + */ + _anyControlsInvalid(index) { + this._steps.toArray()[this._selectedIndex].interacted = true; + if (this._linear && index >= 0) { + return this._steps.toArray().slice(0, index).some(step => step.stepControl.invalid); + } + return false; + } + /** + * @return {?} + */ + _layoutDirection() { + return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr'; + } +} +CdkStepper.decorators = [ + { type: Directive, args: [{ + selector: '[cdkStepper]', + exportAs: 'cdkStepper', + },] }, +]; +/** + * @nocollapse + */ +CdkStepper.ctorParameters = () => [ + { type: Directionality, decorators: [{ type: Optional },] }, + { type: ChangeDetectorRef, }, +]; +CdkStepper.propDecorators = { + '_steps': [{ type: ContentChildren, args: [CdkStep,] },], + 'linear': [{ type: Input },], + 'selectedIndex': [{ type: Input },], + 'selected': [{ type: Input },], + 'selectionChange': [{ type: Output },], +}; + +/** + * Button that moves to the next step in a stepper workflow. + */ +class CdkStepperNext { + /** + * @param {?} _stepper + */ + constructor(_stepper) { + this._stepper = _stepper; + } +} +CdkStepperNext.decorators = [ + { type: Directive, args: [{ + selector: 'button[cdkStepperNext]', + host: { '(click)': '_stepper.next()' } + },] }, +]; +/** + * @nocollapse + */ +CdkStepperNext.ctorParameters = () => [ + { type: CdkStepper, }, +]; +/** + * Button that moves to the previous step in a stepper workflow. + */ +class CdkStepperPrevious { + /** + * @param {?} _stepper + */ + constructor(_stepper) { + this._stepper = _stepper; + } +} +CdkStepperPrevious.decorators = [ + { type: Directive, args: [{ + selector: 'button[cdkStepperPrevious]', + host: { '(click)': '_stepper.previous()' } + },] }, +]; +/** + * @nocollapse + */ +CdkStepperPrevious.ctorParameters = () => [ + { type: CdkStepper, }, +]; + +class CdkStepperModule { +} +CdkStepperModule.decorators = [ + { type: NgModule, args: [{ + imports: [BidiModule, CommonModule], + exports: [CdkStep, CdkStepper, CdkStepLabel, CdkStepperNext, CdkStepperPrevious], + declarations: [CdkStep, CdkStepper, CdkStepLabel, CdkStepperNext, CdkStepperPrevious] + },] }, +]; +/** + * @nocollapse + */ +CdkStepperModule.ctorParameters = () => []; + +/** + * Generated bundle index. Do not edit. + */ + +export { StepperSelectionEvent, CdkStep, CdkStepper, CdkStepLabel, CdkStepperNext, CdkStepperPrevious, CdkStepperModule }; +//# sourceMappingURL=stepper.js.map http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/esm2015/stepper.js.map ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/esm2015/stepper.js.map b/node_modules/@angular/cdk/esm2015/stepper.js.map new file mode 100644 index 0000000..4d0c9fa --- /dev/null +++ b/node_modules/@angular/cdk/esm2015/stepper.js.map @@ -0,0 +1 @@ +{"version":3,"file":"stepper.js","sources":["../../packages/cdk/stepper/step-label.js","../../packages/cdk/stepper/stepper.js","../../packages/cdk/stepper/stepper-button.js","../../packages/cdk/stepper/stepper-module.js","../../packages/cdk/stepper/index.js"],"sourcesContent":["/**\n * @license\n * Copyright Google Inc. 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 */\nimport { Directive, TemplateRef } from '@angular/core';\nexport class CdkStepLabel {\n /**\n * @param {?} template\n */\n constructor(template) {\n this.template = template;\n }\n}\nCdkStepLabel.decorators = [\n { type: Directive, args: [{\n selector: '[cdkStepLabel]',\n },] },\n];\n/**\n * @nocollapse\n */\nCdkStepLabel.ctorParameters = () => [\n { type: TemplateRef, },\n];\nfunction CdkStepLabel_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStepLabel.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStepLabel.ctorParameters;\n /** @type {?} */\n CdkStepLabel.prototype.template;\n}\n//# sourceMappingURL=step-label.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { ContentChildren, EventEmitter, Input, Output, Directive, Component, ContentChild, ViewChild, TemplateRef, ViewEncapsulation, Optional, Inject, forwardRef, ChangeDetectionStrategy, ChangeDetectorRef, } from '@angular/core';\nimport { LEFT_ARROW, RIGHT_ARROW, ENTER, SPACE } from '@angular/cdk/keycodes';\nimport { CdkStepLabel } from './step-label';\nimport { coerceBooleanProperty } from '@angular/cdk/coercion';\nimport { Directionality } from '@angular/cdk/bidi';\n/**\n * Used to generate unique ID for each stepper component.\n */\nlet nextId = 0;\n/**\n * Change event emitted on selection changes.\n */\nexport class StepperSelectionEvent {\n}\nfunction StepperSelectionEvent_tsickle_Closure_declarations() {\n /**\n * Index of the step now selected.\n * @type {?}\n */\n StepperSelectionEvent.prototype.selectedIndex;\n /**\n * Index of the step previously selected.\n * @type {?}\n */\n StepperSelectionEvent.prototype.previouslySelectedIndex;\n /**\n * The step instance now selected.\n * @type {?}\n */\n StepperSelectionEvent.prototype.selectedStep;\n /**\n * The step instance previously selected.\n * @type {?}\n */\n StepperSelectionEvent.prototype.previouslySelectedStep;\n}\nexport class CdkStep {\n /**\n * @param {?} _stepper\n */\n constructor(_stepper) {\n this._stepper = _stepper;\n /**\n * Whether user has seen the expanded step content or not.\n */\n this.interacted = false;\n this._editabl e = true;\n this._optional = false;\n this._customCompleted = null;\n }\n /**\n * @return {?}\n */\n get editable() { return this._editable; }\n /**\n * @param {?} value\n * @return {?}\n */\n set editable(value) {\n this._editable = coerceBooleanProperty(value);\n }\n /**\n * Whether the completion of step is optional or not.\n * @return {?}\n */\n get optional() { return this._optional; }\n /**\n * @param {?} value\n * @return {?}\n */\n set optional(value) {\n this._optional = coerceBooleanProperty(value);\n }\n /**\n * Return whether step is completed or not.\n * @return {?}\n */\n get completed() {\n return this._customCompleted == null ? this._defaultCompleted : this._customCompleted;\n }\n /**\n * @param {?} value\n * @return {?}\n */\n set completed(value) {\n this._customCompleted = coerceBooleanProperty(value);\n } \n /**\n * @return {?}\n */\n get _defaultCompleted() {\n return this.stepControl ? this.stepControl.valid && this.interacted : this.interacted;\n }\n /**\n * Selects this step component.\n * @return {?}\n */\n select() {\n this._stepper.selected = this;\n }\n /**\n * @return {?}\n */\n ngOnChanges() {\n // Since basically all inputs of the MdStep get proxied through the view down to the\n // underlying MdStepHeader, we have to make sure that change detection runs correctly.\n this._stepper._stateChanged();\n }\n}\nCdkStep.decorators = [\n { type: Component, args: [{selector: 'cdk-step',\n exportAs: 'cdkStep',\n template: \"<ng-template><ng-content></ng-content></ng-template>\",\n encapsulation: ViewEncapsulation.None,\n preserveWhitespaces: false,\n changeDetection: ChangeDetectionStrategy.OnPush,\n },] }, \n];\n/**\n * @nocollapse\n */\nCdkStep.ctorParameters = () => [\n { type: CdkStepper, decorators: [{ type: Inject, args: [forwardRef(() => CdkStepper),] },] },\n];\nCdkStep.propDecorators = {\n 'stepLabel': [{ type: ContentChild, args: [CdkStepLabel,] },],\n 'content': [{ type: ViewChild, args: [TemplateRef,] },],\n 'stepControl': [{ type: Input },],\n 'label': [{ type: Input },],\n 'editable': [{ type: Input },],\n 'optional': [{ type: Input },],\n 'completed': [{ type: Input },],\n};\nfunction CdkStep_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStep.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStep.ctorParameters;\n /** @type {?} */\n CdkStep.propDecorators;\n /**\n * Template for step label if it exists.\n * @type {?}\n */\n CdkStep.prototype.stepLabel;\n /**\n * Template for step content.\n * @type {?}\n */\n CdkStep.prototype.content;\n /**\n * The top lev el abstract control of the step.\n * @type {?}\n */\n CdkStep.prototype.stepControl;\n /**\n * Whether user has seen the expanded step content or not.\n * @type {?}\n */\n CdkStep.prototype.interacted;\n /**\n * Label of the step.\n * @type {?}\n */\n CdkStep.prototype.label;\n /** @type {?} */\n CdkStep.prototype._editable;\n /** @type {?} */\n CdkStep.prototype._optional;\n /** @type {?} */\n CdkStep.prototype._customCompleted;\n /** @type {?} */\n CdkStep.prototype._stepper;\n}\nexport class CdkStepper {\n /**\n * @param {?} _dir\n * @param {?} _changeDetectorRef\n */\n constructor(_dir, _changeDetectorRef) {\n this._dir = _dir;\n this._changeDetectorRef = _changeDetectorRef;\n this._linear = false;\n this._selectedIndex = 0;\n /**\n * Event emitted when the selected step has changed.\n */\n this.selectionChange = new EventEmitter();\n /**\n * The index of the step that the focus can be set.\n */\n this._focusIndex = 0;\n this._groupId = nextId++;\n }\n /**\n * Whether the validity of previous steps should be checked or not.\n * @return {?}\n */\n get linear() { return this._linear; }\n /**\n * @param {?} value\n * @return {?}\n */\n set linear(value) { this._linear = coerceBooleanProperty(value); }\n /**\n * The index of the selected step.\n * @return {?}\n */\n get selectedIndex() { return this._selectedIndex; }\n /**\n * @param {?} index\n * @return {?}\n */\n set selectedIndex(index) {\n if (this._anyControlsInvalid(index)\n || index < this._selectedIndex && !this._steps.toArray()[index].editable) {\n // remove focus from clicked step header if the step is not able to be selected\n this._stepHeader.toArray()[index].nativeElement.blur();\n }\n els e if (this._selectedIndex != index) {\n this._emitStepperSelectionEvent(index);\n this._focusIndex = this._selectedIndex;\n }\n }\n /**\n * The step that is selected.\n * @return {?}\n */\n get selected() { return this._steps.toArray()[this.selectedIndex]; }\n /**\n * @param {?} step\n * @return {?}\n */\n set selected(step) {\n this.selectedIndex = this._steps.toArray().indexOf(step);\n }\n /**\n * Selects and focuses the next step in list.\n * @return {?}\n */\n next() {\n this.selectedIndex = Math.min(this._selectedIndex + 1, this._steps.length - 1);\n }\n /**\n * Selects and focuses the previous step in list.\n * @return {?}\n */\n previous() {\n this.selectedIndex = Math.max(this._selectedIndex - 1, 0);\n }\n /**\n * Returns a unique id for each step label element.\n * @param {?} i\n * @return {?}\n */\n _getStepLabelId(i) { \n return `mat-step-label-${this._groupId}-${i}`;\n }\n /**\n * Returns unique id for each step content element.\n * @param {?} i\n * @return {?}\n */\n _getStepContentId(i) {\n return `mat-step-content-${this._groupId}-${i}`;\n }\n /**\n * Marks the component to be change detected.\n * @return {?}\n */\n _stateChanged() {\n this._changeDetectorRef.markForCheck();\n }\n /**\n * Returns position state of the step with the given index.\n * @param {?} index\n * @return {?}\n */\n _getAnimationDirection(index) {\n const /** @type {?} */ position = index - this._selectedIndex;\n if (position < 0) {\n return this._layoutDirection() === 'rtl' ? 'next' : 'previous';\n }\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 b e displayed.\n * @param {?} index\n * @return {?}\n */\n _getIndicatorType(index) {\n const /** @type {?} */ step = this._steps.toArray()[index];\n if (!step.completed || this._selectedIndex == index) {\n return 'number';\n }\n else {\n return step.editable ? 'edit' : 'done';\n }\n }\n /**\n * @param {?} newIndex\n * @return {?}\n */\n _emitStepperSelectionEvent(newIndex) {\n const /** @type {?} */ 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 this._selectedIndex = newIndex;\n this._stateChanged();\n }\n /**\n * @param {?} event\n * @return {?}\n */\n _onKeydown(event) {\n switch (event.key Code) {\n case RIGHT_ARROW:\n if (this._layoutDirection() === 'rtl') {\n this._focusPreviousStep();\n }\n else {\n this._focusNextStep();\n }\n break;\n case LEFT_ARROW:\n if (this._layoutDirection() === 'rtl') {\n this._focusNextStep();\n }\n else {\n this._focusPreviousStep();\n }\n break;\n case SPACE:\n case ENTER:\n this.selectedIndex = this._focusIndex;\n break;\n default:\n // Return to avoid calling preventDefault on keys that are not explicitly handled.\n return;\n }\n event.preventDefault();\n }\n /**\n * @return {?}\n */\n _focusNextStep() {\n this._focusStep((this._focusIndex + 1) % this._steps.leng th);\n }\n /**\n * @return {?}\n */\n _focusPreviousStep() {\n this._focusStep((this._focusIndex + this._steps.length - 1) % this._steps.length);\n }\n /**\n * @param {?} index\n * @return {?}\n */\n _focusStep(index) {\n this._focusIndex = index;\n this._stepHeader.toArray()[this._focusIndex].nativeElement.focus();\n }\n /**\n * @param {?} index\n * @return {?}\n */\n _anyControlsInvalid(index) {\n this._steps.toArray()[this._selectedIndex].interacted = true;\n if (this._linear && index >= 0) {\n return this._steps.toArray().slice(0, index).some(step => step.stepControl.invalid);\n }\n return false;\n }\n /**\n * @return {?}\n */\n _layoutDirection() {\n return this._dir && this._dir.value === 'rtl' ? 'rtl' : 'ltr';\n }\n}\nCdkStepper.decorators = [\n { type: Directive, args: [{\n selector: '[cdkStepper]',\n exportAs: 'cdkStepper',\n },] },\n];\n/**\n * @nocollapse\n */\nCdkStepper.ctorParameters = () => [\n { type: Directionality, decorators: [{ type: Optional },] },\n { type: ChangeDetectorRef, },\n];\nCdkStepper.propDecorators = {\n '_steps': [{ type: ContentChildren, args: [CdkStep,] },],\n 'linear': [{ type: Input },],\n 'selectedIndex': [{ type: Input },],\n 'selected': [{ type: Input },],\n 'selectionChange': [{ type: Output },],\n};\nfunction CdkStepper_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStepper.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStepper.ctorParameters;\n /** @type {?} */\n CdkStepper.propDecorators;\n /**\n * The list of step components that the stepper is holding.\n * @type {?}\n */\n CdkStepper.prototype._steps;\n /**\n * The list of step headers of the steps in the stepper.\n * @type {?}\n */\n CdkStepper.prototype._stepHeader;\n /** @type {?} */\n CdkStepper.prototype._linear;\n /** @type {?} */\n CdkStepper.prototype._selectedIndex;\n /**\n * Event emitted when the selected step has changed.\n * @type {?}\n */\n CdkStepper.prototype.selectionChange;\n /**\n * The index of the step that the focus can be set.\n * @type {?}\n */\n CdkStepper.prototype._focusIndex;\n /**\n * Used to track unique ID for each stepper component.\n * @type {?}\n */\n CdkStepper.prototype._groupId;\n /** @type {?} */\n CdkStepper.prototype._dir;\n /** @type {?} */\n CdkStepper.prototype._changeDetectorRef;\n}\n//# sourceMappingURL=stepper.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { Directive } from '@angular/core';\nimport { CdkStepper } from './stepper';\n/**\n * Button that moves to the next step in a stepper workflow.\n */\nexport class CdkStepperNext {\n /**\n * @param {?} _stepper\n */\n constructor(_stepper) {\n this._stepper = _stepper;\n }\n}\nCdkStepperNext.decorators = [\n { type: Directive, args: [{\n selector: 'button[cdkStepperNext]',\n host: { '(click)': '_stepper.next()' }\n },] },\n];\n/**\n * @nocollapse\n */\nCdkStepperNext.ctorParameters = () => [\n { type: CdkStepper, },\n];\nfunction CdkStepperNext_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStepperNext.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStepperNext.ctorParameters;\n /** @type {?} */\n CdkStepperNext.prototype._stepper;\n}\n/**\n * Button that moves to the previous step in a stepper workflow.\n */\nexport class CdkStepperPrevious {\n /**\n * @param {?} _stepper\n */\n constructor(_stepper) {\n this._stepper = _stepper;\n }\n }\nCdkStepperPrevious.decorators = [\n { type: Directive, args: [{\n selector: 'button[cdkStepperPrevious]',\n host: { '(click)': '_stepper.previous()' }\n },] },\n];\n/**\n * @nocollapse\n */\nCdkStepperPrevious.ctorParameters = () => [\n { type: CdkStepper, },\n];\nfunction CdkStepperPrevious_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStepperPrevious.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStepperPrevious.ctorParameters;\n /** @type {?} */\n CdkStepperPrevious.prototype._stepper;\n}\n//# sourceMappingURL=stepper-button.js.map","/**\n * @license\n * Copyright Google Inc. 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 */\nimport { NgModule } from '@angular/core';\nimport { CdkStepper, CdkStep } from './stepper';\nimport { CommonModule } from '@angular/common';\n import { CdkStepLabel } from './step-label';\nimport { CdkStepperNext, CdkStepperPrevious } from './stepper-button';\nimport { BidiModule } from '@angular/cdk/bidi';\nexport class CdkStepperModule {\n}\nCdkStepperModule.decorators = [\n { type: NgModule, args: [{\n imports: [BidiModule, CommonModule],\n exports: [CdkStep, CdkStepper, CdkStepLabel, CdkStepperNext, CdkStepperPrevious],\n declarations: [CdkStep, CdkStepper, CdkStepLabel, CdkStepperNext, CdkStepperPrevious]\n },] },\n];\n/**\n * @nocollapse\n */\nCdkStepperModule.ctorParameters = () => [];\nfunction CdkStepperModule_tsickle_Closure_declarations() {\n /** @type {?} */\n CdkStepperModule.decorators;\n /**\n * @nocollapse\n * @type {?}\n */\n CdkStepperModule.ctorParameters;\n}\n//# sourceMappingURL=stepper-module.js.map","/**\n * Generated bundle index. Do not edit.\n */\nexport { StepperSelectionEvent, CdkStep, CdkStepper, CdkStepLabel, Cd kStepperNext, CdkStepperPrevious, CdkStepperModule } from './public-api';\n//# sourceMappingURL=index.js.map"],"names":[],"mappings":"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"} \ No newline at end of file
