http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/animation_event.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/animation_event.d.ts b/node_modules/@angular/animations/src/animation_event.d.ts new file mode 100644 index 0000000..3777ff4 --- /dev/null +++ b/node_modules/@angular/animations/src/animation_event.d.ts @@ -0,0 +1,46 @@ +/** + * @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 + */ +/** + * An instance of this class is returned as an event parameter when an animation + * callback is captured for an animation either during the start or done phase. + * + * ```typescript + * @Component({ + * host: { + * '[@myAnimationTrigger]': 'someExpression', + * '(@myAnimationTrigger.start)': 'captureStartEvent($event)', + * '(@myAnimationTrigger.done)': 'captureDoneEvent($event)', + * }, + * animations: [ + * trigger("myAnimationTrigger", [ + * // ... + * ]) + * ] + * }) + * class MyComponent { + * someExpression: any = false; + * captureStartEvent(event: AnimationEvent) { + * // the toState, fromState and totalTime data is accessible from the event variable + * } + * + * captureDoneEvent(event: AnimationEvent) { + * // the toState, fromState and totalTime data is accessible from the event variable + * } + * } + * ``` + * + * @experimental Animation support is experimental. + */ +export interface AnimationEvent { + fromState: string; + toState: string; + totalTime: number; + phaseName: string; + element: any; + triggerName: string; +}
http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/animation_metadata.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/animation_metadata.d.ts b/node_modules/@angular/animations/src/animation_metadata.d.ts new file mode 100644 index 0000000..4d97eb8 --- /dev/null +++ b/node_modules/@angular/animations/src/animation_metadata.d.ts @@ -0,0 +1,1053 @@ +/** + * @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 + */ +export interface ɵStyleData { + [key: string]: string | number; +} +/** + * Metadata representing the entry of animations. Instances of this interface are created internally + * within the Angular animation DSL. + * + * @experimental Animation support is experimental. + */ +export declare type AnimateTimings = { + duration: number; + delay: number; + easing: string | null; +}; +/** + * `AnimationOptions` represents options that can be passed into most animation DSL methods. + * When options are provided, the delay value of an animation can be changed and animation input + * parameters can be passed in to change styling and timing data when an animation is started. + * + * The following animation DSL functions are able to accept animation option data: + * + * - {@link transition transition()} + * - {@link sequence sequence()} + * - {@link group group()} + * - {@link query query()} + * - {@link animation animation()} + * - {@link useAnimation useAnimation()} + * - {@link animateChild animateChild()} + * + * Programmatic animations built using {@link AnimationBuilder the AnimationBuilder service} also + * make use of AnimationOptions. + * + * @experimental Animation support is experimental. + */ +export interface AnimationOptions { + delay?: number | string; + params?: { + [name: string]: any; + }; +} +/** + * Metadata representing the entry of animations. Instances of this interface are created internally + * within the Angular animation DSL when {@link animateChild animateChild()} is used. + * + * @experimental Animation support is experimental. + */ +export interface AnimateChildOptions extends AnimationOptions { + duration?: number | string; +} +/** + * Metadata representing the entry of animations. Usages of this enum are created + * each time an animation DSL function is used. + * + * @experimental Animation support is experimental. + */ +export declare const enum AnimationMetadataType { + State = 0, + Transition = 1, + Sequence = 2, + Group = 3, + Animate = 4, + Keyframes = 5, + Style = 6, + Trigger = 7, + Reference = 8, + AnimateChild = 9, + AnimateRef = 10, + Query = 11, + Stagger = 12, +} +/** + * @experimental Animation support is experimental. + */ +export declare const AUTO_STYLE = "*"; +/** + * @experimental Animation support is experimental. + */ +export interface AnimationMetadata { + type: AnimationMetadataType; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link trigger trigger animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationTriggerMetadata extends AnimationMetadata { + name: string; + definitions: AnimationMetadata[]; + options: { + params?: { + [name: string]: any; + }; + } | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link state state animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationStateMetadata extends AnimationMetadata { + name: string; + styles: AnimationStyleMetadata; + options?: { + params: { + [name: string]: any; + }; + }; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link transition transition animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationTransitionMetadata extends AnimationMetadata { + expr: string; + animation: AnimationMetadata | AnimationMetadata[]; + options: AnimationOptions | null; +} +/** + * @experimental Animation support is experimental. + */ +export interface AnimationReferenceMetadata extends AnimationMetadata { + animation: AnimationMetadata | AnimationMetadata[]; + options: AnimationOptions | null; +} +/** + * @experimental Animation support is experimental. + */ +export interface AnimationQueryMetadata extends AnimationMetadata { + selector: string; + animation: AnimationMetadata | AnimationMetadata[]; + options: AnimationQueryOptions | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link keyframes keyframes animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationKeyframesSequenceMetadata extends AnimationMetadata { + steps: AnimationStyleMetadata[]; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link style style animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationStyleMetadata extends AnimationMetadata { + styles: '*' | { + [key: string]: string | number; + } | Array<{ + [key: string]: string | number; + } | '*'>; + offset: number | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link animate animate animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationAnimateMetadata extends AnimationMetadata { + timings: string | number | AnimateTimings; + styles: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link animateChild animateChild animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationAnimateChildMetadata extends AnimationMetadata { + options: AnimationOptions | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link useAnimation useAnimation animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationAnimateRefMetadata extends AnimationMetadata { + animation: AnimationReferenceMetadata; + options: AnimationOptions | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link sequence sequence animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationSequenceMetadata extends AnimationMetadata { + steps: AnimationMetadata[]; + options: AnimationOptions | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link group group animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationGroupMetadata extends AnimationMetadata { + steps: AnimationMetadata[]; + options: AnimationOptions | null; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link query query animation function} is called. + * + * @experimental Animation support is experimental. + */ +export interface AnimationQueryOptions extends AnimationOptions { + optional?: boolean; + /** + * Used to limit the total amount of results from the start of the query list. + * + * If a negative value is provided then the queried results will be limited from the + * end of the query list towards the beginning (e.g. if `limit: -3` is used then the + * final 3 (or less) queried results will be used for the animation). + */ + limit?: number; +} +/** + * Metadata representing the entry of animations. Instances of this interface are provided via the + * animation DSL when the {@link stagger stagger animation function} is called. + * +* @experimental Animation support is experimental. +*/ +export interface AnimationStaggerMetadata extends AnimationMetadata { + timings: string | number; + animation: AnimationMetadata | AnimationMetadata[]; +} +/** + * `trigger` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the + * {@link Component#animations component animations metadata page} to gain a better + * understanding of how animations in Angular are used. + * + * `trigger` Creates an animation trigger which will a list of {@link state state} and + * {@link transition transition} entries that will be evaluated when the expression + * bound to the trigger changes. + * + * Triggers are registered within the component annotation data under the + * {@link Component#animations animations section}. An animation trigger can be placed on an element + * within a template by referencing the name of the trigger followed by the expression value that + the + * trigger is bound to (in the form of `[@triggerName]="expression"`. + * + * Animation trigger bindings strigify values and then match the previous and current values against + * any linked transitions. If a boolean value is provided into the trigger binding then it will both + * be represented as `1` or `true` and `0` or `false` for a true and false boolean values + * respectively. + * + * ### Usage + * + * `trigger` will create an animation trigger reference based on the provided `name` value. The + * provided `animation` value is expected to be an array consisting of {@link state state} and + * {@link transition transition} declarations. + * + * ```typescript + * @Component({ + * selector: 'my-component', + * templateUrl: 'my-component-tpl.html', + * animations: [ + * trigger("myAnimationTrigger", [ + * state(...), + * state(...), + * transition(...), + * transition(...) + * ]) + * ] + * }) + * class MyComponent { + * myStatusExp = "something"; + * } + * ``` + * + * The template associated with this component will make use of the `myAnimationTrigger` animation + trigger by binding to an element within its template code. + * + * ```html + * <!-- somewhere inside of my-component-tpl.html --> + * <div [@myAnimationTrigger]="myStatusExp">...</div> + * ``` + * + * ## Disable Animations + * A special animation control binding called `@.disabled` can be placed on an element which will + then disable animations for any inner animation triggers situated within the element as well as + any animations on the element itself. + * + * When true, the `@.disabled` binding will prevent all animations from rendering. The example + below shows how to use this feature: + * + * ```ts + * @Component({ + * selector: 'my-component', + * template: ` + * <div [@.disabled]="isDisabled"> + * <div [@childAnimation]="exp"></div> + * </div> + * `, + * animations: [ + * trigger("childAnimation", [ + * // ... + * ]) + * ] + * }) + * class MyComponent { + * isDisabled = true; + * exp = '...'; + * } + * ``` + * + * The `@childAnimation` trigger will not animate because `@.disabled` prevents it from happening + (when true). + * + * Note that `@.disbled` will only disable all animations (this means any animations running on + * the same element will also be disabled). + * + * ### Disabling Animations Application-wide + * When an area of the template is set to have animations disabled, **all** inner components will + also have their animations disabled as well. This means that all animations for an angular + application can be disabled by placing a host binding set on `@.disabled` on the topmost Angular + component. + * + * ```ts + * import {Component, HostBinding} from '@angular/core'; + * + * @Component({ + * selector: 'app-component', + * templateUrl: 'app.component.html', + * }) + * class AppComponent { + * @HostBinding('@.disabled') + * public animationsDisabled = true; + * } + * ``` + * + * ### What about animations that us `query()` and `animateChild()`? + * Despite inner animations being disabled, a parent animation can {@link query query} for inner + elements located in disabled areas of the template and still animate them as it sees fit. This is + also the case for when a sub animation is queried by a parent and then later animated using {@link + animateChild animateChild}. + * + * @experimental Animation support is experimental. + */ +export declare function trigger(name: string, definitions: AnimationMetadata[]): AnimationTriggerMetadata; +/** + * `animate` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `animate` specifies an animation step that will apply the provided `styles` data for a given + * amount of time based on the provided `timing` expression value. Calls to `animate` are expected + * to be used within {@link sequence an animation sequence}, {@link group group}, or {@link + * transition transition}. + * + * ### Usage + * + * The `animate` function accepts two input parameters: `timing` and `styles`: + * + * - `timing` is a string based value that can be a combination of a duration with optional delay + * and easing values. The format for the expression breaks down to `duration delay easing` + * (therefore a value such as `1s 100ms ease-out` will be parse itself into `duration=1000, + * delay=100, easing=ease-out`. If a numeric value is provided then that will be used as the + * `duration` value in millisecond form. + * - `styles` is the style input data which can either be a call to {@link style style} or {@link + * keyframes keyframes}. If left empty then the styles from the destination state will be collected + * and used (this is useful when describing an animation step that will complete an animation by + * {@link transition#the-final-animate-call animating to the final state}). + * + * ```typescript + * // various functions for specifying timing data + * animate(500, style(...)) + * animate("1s", style(...)) + * animate("100ms 0.5s", style(...)) + * animate("5s ease", style(...)) + * animate("5s 10ms cubic-bezier(.17,.67,.88,.1)", style(...)) + * + * // either style() of keyframes() can be used + * animate(500, style({ background: "red" })) + * animate(500, keyframes([ + * style({ background: "blue" })), + * style({ background: "red" })) + * ]) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function animate(timings: string | number, styles?: AnimationStyleMetadata | AnimationKeyframesSequenceMetadata | null): AnimationAnimateMetadata; +/** + * `group` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `group` specifies a list of animation steps that are all run in parallel. Grouped animations are + * useful when a series of styles must be animated/closed off at different starting/ending times. + * + * The `group` function can either be used within a {@link sequence sequence} or a {@link transition + * transition} and it will only continue to the next instruction once all of the inner animation + * steps have completed. + * + * ### Usage + * + * The `steps` data that is passed into the `group` animation function can either consist of {@link + * style style} or {@link animate animate} function calls. Each call to `style()` or `animate()` + * within a group will be executed instantly (use {@link keyframes keyframes} or a {@link + * animate#usage animate() with a delay value} to offset styles to be applied at a later time). + * + * ```typescript + * group([ + * animate("1s", { background: "black" })) + * animate("2s", { color: "white" })) + * ]) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function group(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationGroupMetadata; +/** + * `sequence` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `sequence` Specifies a list of animation steps that are run one by one. (`sequence` is used by + * default when an array is passed as animation data into {@link transition transition}.) + * + * The `sequence` function can either be used within a {@link group group} or a {@link transition + * transition} and it will only continue to the next instruction once each of the inner animation + * steps have completed. + * + * To perform animation styling in parallel with other animation steps then have a look at the + * {@link group group} animation function. + * + * ### Usage + * + * The `steps` data that is passed into the `sequence` animation function can either consist of + * {@link style style} or {@link animate animate} function calls. A call to `style()` will apply the + * provided styling data immediately while a call to `animate()` will apply its styling data over a + * given time depending on its timing data. + * + * ```typescript + * sequence([ + * style({ opacity: 0 })), + * animate("1s", { opacity: 1 })) + * ]) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function sequence(steps: AnimationMetadata[], options?: AnimationOptions | null): AnimationSequenceMetadata; +/** + * `style` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `style` declares a key/value object containing CSS properties/styles that can then be used for + * {@link state animation states}, within an {@link sequence animation sequence}, or as styling data + * for both {@link animate animate} and {@link keyframes keyframes}. + * + * ### Usage + * + * `style` takes in a key/value string map as data and expects one or more CSS property/value pairs + * to be defined. + * + * ```typescript + * // string values are used for css properties + * style({ background: "red", color: "blue" }) + * + * // numerical (pixel) values are also supported + * style({ width: 100, height: 0 }) + * ``` + * + * #### Auto-styles (using `*`) + * + * When an asterix (`*`) character is used as a value then it will be detected from the element + * being animated and applied as animation data when the animation starts. + * + * This feature proves useful for a state depending on layout and/or environment factors; in such + * cases the styles are calculated just before the animation starts. + * + * ```typescript + * // the steps below will animate from 0 to the + * // actual height of the element + * style({ height: 0 }), + * animate("1s", style({ height: "*" })) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function style(tokens: '*' | { + [key: string]: string | number; +} | Array<'*' | { + [key: string]: string | number; +}>): AnimationStyleMetadata; +/** + * `state` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `state` declares an animation state within the given trigger. When a state is active within a + * component then its associated styles will persist on the element that the trigger is attached to + * (even when the animation ends). + * + * To animate between states, have a look at the animation {@link transition transition} DSL + * function. To register states to an animation trigger please have a look at the {@link trigger + * trigger} function. + * + * #### The `void` state + * + * The `void` state value is a reserved word that angular uses to determine when the element is not + * apart of the application anymore (e.g. when an `ngIf` evaluates to false then the state of the + * associated element is void). + * + * #### The `*` (default) state + * + * The `*` state (when styled) is a fallback state that will be used if the state that is being + * animated is not declared within the trigger. + * + * ### Usage + * + * `state` will declare an animation state with its associated styles + * within the given trigger. + * + * - `stateNameExpr` can be one or more state names separated by commas. + * - `styles` refers to the {@link style styling data} that will be persisted on the element once + * the state has been reached. + * + * ```typescript + * // "void" is a reserved name for a state and is used to represent + * // the state in which an element is detached from from the application. + * state("void", style({ height: 0 })) + * + * // user-defined states + * state("closed", style({ height: 0 })) + * state("open, visible", style({ height: "*" })) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function state(name: string, styles: AnimationStyleMetadata, options?: { + params: { + [name: string]: any; + }; +}): AnimationStateMetadata; +/** + * `keyframes` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `keyframes` specifies a collection of {@link style style} entries each optionally characterized + * by an `offset` value. + * + * ### Usage + * + * The `keyframes` animation function is designed to be used alongside the {@link animate animate} + * animation function. Instead of applying animations from where they are currently to their + * destination, keyframes can describe how each style entry is applied and at what point within the + * animation arc (much like CSS Keyframe Animations do). + * + * For each `style()` entry an `offset` value can be set. Doing so allows to specifiy at what + * percentage of the animate time the styles will be applied. + * + * ```typescript + * // the provided offset values describe when each backgroundColor value is applied. + * animate("5s", keyframes([ + * style({ backgroundColor: "red", offset: 0 }), + * style({ backgroundColor: "blue", offset: 0.2 }), + * style({ backgroundColor: "orange", offset: 0.3 }), + * style({ backgroundColor: "black", offset: 1 }) + * ])) + * ``` + * + * Alternatively, if there are no `offset` values used within the style entries then the offsets + * will be calculated automatically. + * + * ```typescript + * animate("5s", keyframes([ + * style({ backgroundColor: "red" }) // offset = 0 + * style({ backgroundColor: "blue" }) // offset = 0.33 + * style({ backgroundColor: "orange" }) // offset = 0.66 + * style({ backgroundColor: "black" }) // offset = 1 + * ])) + * ``` + * + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function keyframes(steps: AnimationStyleMetadata[]): AnimationKeyframesSequenceMetadata; +/** + * `transition` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. If this information is new, please navigate to the {@link + * Component#animations component animations metadata page} to gain a better understanding of + * how animations in Angular are used. + * + * `transition` declares the {@link sequence sequence of animation steps} that will be run when the + * provided `stateChangeExpr` value is satisfied. The `stateChangeExpr` consists of a `state1 => + * state2` which consists of two known states (use an asterix (`*`) to refer to a dynamic starting + * and/or ending state). + * + * A function can also be provided as the `stateChangeExpr` argument for a transition and this + * function will be executed each time a state change occurs. If the value returned within the + * function is true then the associated animation will be run. + * + * Animation transitions are placed within an {@link trigger animation trigger}. For an transition + * to animate to a state value and persist its styles then one or more {@link state animation + * states} is expected to be defined. + * + * ### Usage + * + * An animation transition is kicked off the `stateChangeExpr` predicate evaluates to true based on + * what the previous state is and what the current state has become. In other words, if a transition + * is defined that matches the old/current state criteria then the associated animation will be + * triggered. + * + * ```typescript + * // all transition/state changes are defined within an animation trigger + * trigger("myAnimationTrigger", [ + * // if a state is defined then its styles will be persisted when the + * // animation has fully completed itself + * state("on", style({ background: "green" })), + * state("off", style({ background: "grey" })), + * + * // a transition animation that will be kicked off when the state value + * // bound to "myAnimationTrigger" changes from "on" to "off" + * transition("on => off", animate(500)), + * + * // it is also possible to do run the same animation for both directions + * transition("on <=> off", animate(500)), + * + * // or to define multiple states pairs separated by commas + * transition("on => off, off => void", animate(500)), + * + * // this is a catch-all state change for when an element is inserted into + * // the page and the destination state is unknown + * transition("void => *", [ + * style({ opacity: 0 }), + * animate(500) + * ]), + * + * // this will capture a state change between any states + * transition("* => *", animate("1s 0s")), + * + * // you can also go full out and include a function + * transition((fromState, toState) => { + * // when `true` then it will allow the animation below to be invoked + * return fromState == "off" && toState == "on"; + * }, animate("1s 0s")) + * ]) + * ``` + * + * The template associated with this component will make use of the `myAnimationTrigger` animation + * trigger by binding to an element within its template code. + * + * ```html + * <!-- somewhere inside of my-component-tpl.html --> + * <div [@myAnimationTrigger]="myStatusExp">...</div> + * ``` + * + * #### The final `animate` call + * + * If the final step within the transition steps is a call to `animate()` that **only** uses a + * timing value with **no style data** then it will be automatically used as the final animation arc + * for the element to animate itself to the final state. This involves an automatic mix of + * adding/removing CSS styles so that the element will be in the exact state it should be for the + * applied state to be presented correctly. + * + * ``` + * // start off by hiding the element, but make sure that it animates properly to whatever state + * // is currently active for "myAnimationTrigger" + * transition("void => *", [ + * style({ opacity: 0 }), + * animate(500) + * ]) + * ``` + * + * ### Transition Aliases (`:enter` and `:leave`) + * + * Given that enter (insertion) and leave (removal) animations are so common, the `transition` + * function accepts both `:enter` and `:leave` values which are aliases for the `void => *` and `* + * => void` state changes. + * + * ``` + * transition(":enter", [ + * style({ opacity: 0 }), + * animate(500, style({ opacity: 1 })) + * ]) + * transition(":leave", [ + * animate(500, style({ opacity: 0 })) + * ]) + * ``` + * + * ### Boolean values + * if a trigger binding value is a boolean value then it can be matched using a transition + * expression that compares `true` and `false` or `1` and `0`. + * + * ``` + * // in the template + * <div [@openClose]="open ? true : false">...</div> + * + * // in the component metadata + * trigger('openClose', [ + * state('true', style({ height: '*' })), + * state('false', style({ height: '0px' })), + * transition('false <=> true', animate(500)) + * ]) + * ``` + * {@example core/animation/ts/dsl/animation_example.ts region='Component'} + * + * @experimental Animation support is experimental. + */ +export declare function transition(stateChangeExpr: string, steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationTransitionMetadata; +/** + * `animation` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. + * + * `var myAnimation = animation(...)` is designed to produce a reusable animation that can be later + * invoked in another animation or sequence. Reusable animations are designed to make use of + * animation parameters and the produced animation can be used via the `useAnimation` method. + * + * ``` + * var fadeAnimation = animation([ + * style({ opacity: '{{ start }}' }), + * animate('{{ time }}', + * style({ opacity: '{{ end }}'})) + * ], { params: { time: '1000ms', start: 0, end: 1 }}); + * ``` + * + * If parameters are attached to an animation then they act as **default parameter values**. When an + * animation is invoked via `useAnimation` then parameter values are allowed to be passed in + * directly. If any of the passed in parameter values are missing then the default values will be + * used. + * + * ``` + * useAnimation(fadeAnimation, { + * params: { + * time: '2s', + * start: 1, + * end: 0 + * } + * }) + * ``` + * + * If one or more parameter values are missing before animated then an error will be thrown. + * + * @experimental Animation support is experimental. + */ +export declare function animation(steps: AnimationMetadata | AnimationMetadata[], options?: AnimationOptions | null): AnimationReferenceMetadata; +/** + * `animateChild` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. It works by allowing a queried element to execute its own + * animation within the animation sequence. + * + * Each time an animation is triggered in angular, the parent animation + * will always get priority and any child animations will be blocked. In order + * for a child animation to run, the parent animation must query each of the elements + * containing child animations and then allow the animations to run using `animateChild`. + * + * The example HTML code below shows both parent and child elements that have animation + * triggers that will execute at the same time. + * + * ```html + * <!-- parent-child.component.html --> + * <button (click)="exp =! exp">Toggle</button> + * <hr> + * + * <div [@parentAnimation]="exp"> + * <header>Hello</header> + * <div [@childAnimation]="exp"> + * one + * </div> + * <div [@childAnimation]="exp"> + * two + * </div> + * <div [@childAnimation]="exp"> + * three + * </div> + * </div> + * ``` + * + * Now when the `exp` value changes to true, only the `parentAnimation` animation will animate + * because it has priority. However, using `query` and `animateChild` each of the inner animations + * can also fire: + * + * ```ts + * // parent-child.component.ts + * import {trigger, transition, animate, style, query, animateChild} from '@angular/animations'; + * @Component({ + * selector: 'parent-child-component', + * animations: [ + * trigger('parentAnimation', [ + * transition('false => true', [ + * query('header', [ + * style({ opacity: 0 }), + * animate(500, style({ opacity: 1 })) + * ]), + * query('@childAnimation', [ + * animateChild() + * ]) + * ]) + * ]), + * trigger('childAnimation', [ + * transition('false => true', [ + * style({ opacity: 0 }), + * animate(500, style({ opacity: 1 })) + * ]) + * ]) + * ] + * }) + * class ParentChildCmp { + * exp: boolean = false; + * } + * ``` + * + * In the animation code above, when the `parentAnimation` transition kicks off it first queries to + * find the header element and fades it in. It then finds each of the sub elements that contain the + * `@childAnimation` trigger and then allows for their animations to fire. + * + * This example can be further extended by using stagger: + * + * ```ts + * query('@childAnimation', stagger(100, [ + * animateChild() + * ])) + * ``` + * + * Now each of the sub animations start off with respect to the `100ms` staggering step. + * + * ## The first frame of child animations + * When sub animations are executed using `animateChild` the animation engine will always apply the + * first frame of every sub animation immediately at the start of the animation sequence. This way + * the parent animation does not need to set any initial styling data on the sub elements before the + * sub animations kick off. + * + * In the example above the first frame of the `childAnimation`'s `false => true` transition + * consists of a style of `opacity: 0`. This is applied immediately when the `parentAnimation` + * animation transition sequence starts. Only then when the `@childAnimation` is queried and called + * with `animateChild` will it then animate to its destination of `opacity: 1`. + * + * Note that this feature designed to be used alongside {@link query query()} and it will only work + * with animations that are assigned using the Angular animation DSL (this means that CSS keyframes + * and transitions are not handled by this API). + * + * @experimental Animation support is experimental. + */ +export declare function animateChild(options?: AnimateChildOptions | null): AnimationAnimateChildMetadata; +/** + * `useAnimation` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. It is used to kick off a reusable animation that is created using {@link + * animation animation()}. + * + * @experimental Animation support is experimental. + */ +export declare function useAnimation(animation: AnimationReferenceMetadata, options?: AnimationOptions | null): AnimationAnimateRefMetadata; +/** + * `query` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. + * + * query() is used to find one or more inner elements within the current element that is + * being animated within the sequence. The provided animation steps are applied + * to the queried element (by default, an array is provided, then this will be + * treated as an animation sequence). + * + * ### Usage + * + * query() is designed to collect mutiple elements and works internally by using + * `element.querySelectorAll`. An additional options object can be provided which + * can be used to limit the total amount of items to be collected. + * + * ```js + * query('div', [ + * animate(...), + * animate(...) + * ], { limit: 1 }) + * ``` + * + * query(), by default, will throw an error when zero items are found. If a query + * has the `optional` flag set to true then this error will be ignored. + * + * ```js + * query('.some-element-that-may-not-be-there', [ + * animate(...), + * animate(...) + * ], { optional: true }) + * ``` + * + * ### Special Selector Values + * + * The selector value within a query can collect elements that contain angular-specific + * characteristics + * using special pseudo-selectors tokens. + * + * These include: + * + * - Querying for newly inserted/removed elements using `query(":enter")`/`query(":leave")` + * - Querying all currently animating elements using `query(":animating")` + * - Querying elements that contain an animation trigger using `query("@triggerName")` + * - Querying all elements that contain an animation triggers using `query("@*")` + * - Including the current element into the animation sequence using `query(":self")` + * + * + * Each of these pseudo-selector tokens can be merged together into a combined query selector + * string: + * + * ``` + * query(':self, .record:enter, .record:leave, @subTrigger', [...]) + * ``` + * + * ### Demo + * + * ``` + * @Component({ + * selector: 'inner', + * template: ` + * <div [@queryAnimation]="exp"> + * <h1>Title</h1> + * <div class="content"> + * Blah blah blah + * </div> + * </div> + * `, + * animations: [ + * trigger('queryAnimation', [ + * transition('* => goAnimate', [ + * // hide the inner elements + * query('h1', style({ opacity: 0 })), + * query('.content', style({ opacity: 0 })), + * + * // animate the inner elements in, one by one + * query('h1', animate(1000, style({ opacity: 1 })), + * query('.content', animate(1000, style({ opacity: 1 })), + * ]) + * ]) + * ] + * }) + * class Cmp { + * exp = ''; + * + * goAnimate() { + * this.exp = 'goAnimate'; + * } + * } + * ``` + * + * @experimental Animation support is experimental. + */ +export declare function query(selector: string, animation: AnimationMetadata | AnimationMetadata[], options?: AnimationQueryOptions | null): AnimationQueryMetadata; +/** + * `stagger` is an animation-specific function that is designed to be used inside of Angular's + * animation DSL language. It is designed to be used inside of an animation {@link query query()} + * and works by issuing a timing gap between after each queried item is animated. + * + * ### Usage + * + * In the example below there is a container element that wraps a list of items stamped out + * by an ngFor. The container element contains an animation trigger that will later be set + * to query for each of the inner items. + * + * ```html + * <!-- list.component.html --> + * <button (click)="toggle()">Show / Hide Items</button> + * <hr /> + * <div [@listAnimation]="items.length"> + * <div *ngFor="let item of items"> + * {{ item }} + * </div> + * </div> + * ``` + * + * The component code for this looks as such: + * + * ```ts + * import {trigger, transition, style, animate, query, stagger} from '@angular/animations'; + * @Component({ + * templateUrl: 'list.component.html', + * animations: [ + * trigger('listAnimation', [ + * //... + * ]) + * ] + * }) + * class ListComponent { + * items = []; + * + * showItems() { + * this.items = [0,1,2,3,4]; + * } + * + * hideItems() { + * this.items = []; + * } + * + * toggle() { + * this.items.length ? this.hideItems() : this.showItems(); + * } + * } + * ``` + * + * And now for the animation trigger code: + * + * ```ts + * trigger('listAnimation', [ + * transition('* => *', [ // each time the binding value changes + * query(':leave', [ + * stagger(100, [ + * animate('0.5s', style({ opacity: 0 })) + * ]) + * ]), + * query(':enter', [ + * style({ opacity: 0 }), + * stagger(100, [ + * animate('0.5s', style({ opacity: 1 })) + * ]) + * ]) + * ]) + * ]) + * ``` + * + * Now each time the items are added/removed then either the opacity + * fade-in animation will run or each removed item will be faded out. + * When either of these animations occur then a stagger effect will be + * applied after each item's animation is started. + * + * @experimental Animation support is experimental. + */ +export declare function stagger(timings: string | number, animation: AnimationMetadata | AnimationMetadata[]): AnimationStaggerMetadata; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/animations.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/animations.d.ts b/node_modules/@angular/animations/src/animations.d.ts new file mode 100644 index 0000000..131bab0 --- /dev/null +++ b/node_modules/@angular/animations/src/animations.d.ts @@ -0,0 +1,17 @@ +/** + * @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 + */ +/** + * @module + * @description + * Entry point for all animation APIs of the animation package. + */ +export { AnimationBuilder, AnimationFactory } from './animation_builder'; +export { AnimationEvent } from './animation_event'; +export { AUTO_STYLE, AnimateChildOptions, AnimateTimings, AnimationAnimateChildMetadata, AnimationAnimateMetadata, AnimationAnimateRefMetadata, AnimationGroupMetadata, AnimationKeyframesSequenceMetadata, AnimationMetadata, AnimationMetadataType, AnimationOptions, AnimationQueryMetadata, AnimationQueryOptions, AnimationReferenceMetadata, AnimationSequenceMetadata, AnimationStaggerMetadata, AnimationStateMetadata, AnimationStyleMetadata, AnimationTransitionMetadata, AnimationTriggerMetadata, animate, animateChild, animation, group, keyframes, query, sequence, stagger, state, style, transition, trigger, useAnimation, ɵStyleData } from './animation_metadata'; +export { AnimationPlayer, NoopAnimationPlayer } from './players/animation_player'; +export * from './private_export'; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/players/animation_group_player.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/players/animation_group_player.d.ts b/node_modules/@angular/animations/src/players/animation_group_player.d.ts new file mode 100644 index 0000000..7cbe2f0 --- /dev/null +++ b/node_modules/@angular/animations/src/players/animation_group_player.d.ts @@ -0,0 +1,31 @@ +import { AnimationPlayer } from './animation_player'; +export declare class AnimationGroupPlayer implements AnimationPlayer { + private _players; + private _onDoneFns; + private _onStartFns; + private _finished; + private _started; + private _destroyed; + private _onDestroyFns; + parentPlayer: AnimationPlayer | null; + totalTime: number; + constructor(_players: AnimationPlayer[]); + private _onFinish(); + init(): void; + onStart(fn: () => void): void; + private _onStart(); + onDone(fn: () => void): void; + onDestroy(fn: () => void): void; + hasStarted(): boolean; + play(): void; + pause(): void; + restart(): void; + finish(): void; + destroy(): void; + private _onDestroy(); + reset(): void; + setPosition(p: number): void; + getPosition(): number; + readonly players: AnimationPlayer[]; + beforeDestroy(): void; +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/players/animation_player.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/players/animation_player.d.ts b/node_modules/@angular/animations/src/players/animation_player.d.ts new file mode 100644 index 0000000..2c08b1e --- /dev/null +++ b/node_modules/@angular/animations/src/players/animation_player.d.ts @@ -0,0 +1,54 @@ +/** + * AnimationPlayer controls an animation sequence that was produced from a programmatic animation. + * (see {@link AnimationBuilder AnimationBuilder} for more information on how to create programmatic + * animations.) + * + * @experimental Animation support is experimental. + */ +export interface AnimationPlayer { + onDone(fn: () => void): void; + onStart(fn: () => void): void; + onDestroy(fn: () => void): void; + init(): void; + hasStarted(): boolean; + play(): void; + pause(): void; + restart(): void; + finish(): void; + destroy(): void; + reset(): void; + setPosition(p: any): void; + getPosition(): number; + parentPlayer: AnimationPlayer | null; + readonly totalTime: number; + beforeDestroy?: () => any; +} +/** + * @experimental Animation support is experimental. + */ +export declare class NoopAnimationPlayer implements AnimationPlayer { + private _onDoneFns; + private _onStartFns; + private _onDestroyFns; + private _started; + private _destroyed; + private _finished; + parentPlayer: AnimationPlayer | null; + totalTime: number; + constructor(); + private _onFinish(); + onStart(fn: () => void): void; + onDone(fn: () => void): void; + onDestroy(fn: () => void): void; + hasStarted(): boolean; + init(): void; + play(): void; + private _onStart(); + pause(): void; + restart(): void; + finish(): void; + destroy(): void; + reset(): void; + setPosition(p: number): void; + getPosition(): number; +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/private_export.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/private_export.d.ts b/node_modules/@angular/animations/src/private_export.d.ts new file mode 100644 index 0000000..606bab2 --- /dev/null +++ b/node_modules/@angular/animations/src/private_export.d.ts @@ -0,0 +1,9 @@ +/** + * @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 + */ +export { AnimationGroupPlayer as ɵAnimationGroupPlayer } from './players/animation_group_player'; +export declare const ɵPRE_STYLE = "!"; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/animations/src/util.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/animations/src/util.d.ts b/node_modules/@angular/animations/src/util.d.ts new file mode 100644 index 0000000..886c668 --- /dev/null +++ b/node_modules/@angular/animations/src/util.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export declare function scheduleMicroTask(cb: () => any): void; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/_a11y.scss ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/_a11y.scss b/node_modules/@angular/cdk/_a11y.scss new file mode 100644 index 0000000..b9bbc41 --- /dev/null +++ b/node_modules/@angular/cdk/_a11y.scss @@ -0,0 +1,23 @@ +@mixin cdk-a11y { + .cdk-visually-hidden { + border: 0; + clip: rect(0 0 0 0); + height: 1px; + margin: -1px; + overflow: hidden; + padding: 0; + position: absolute; + width: 1px; + } +} + +/** + * Applies styles for users in high contrast mode. Note that this only applies + * to Microsoft browsers. Chrome can be included by checking for the `html[hc]` + * attribute, however Chrome handles high contrast differently. + */ +@mixin cdk-high-contrast { + @media screen and (-ms-high-contrast: active) { + @content; + } +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/_overlay.scss ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/_overlay.scss b/node_modules/@angular/cdk/_overlay.scss new file mode 100644 index 0000000..766bd60 --- /dev/null +++ b/node_modules/@angular/cdk/_overlay.scss @@ -0,0 +1,93 @@ +// We want overlays to always appear over user content, so set a baseline +// very high z-index for the overlay container, which is where we create the new +// stacking context for all overlays. +$cdk-z-index-overlay-container: 1000; +$cdk-z-index-overlay: 1000; +$cdk-z-index-overlay-backdrop: 1000; + +// Background color for all of the backdrops +$cdk-overlay-dark-backdrop-background: rgba(0, 0, 0, 0.6); + +// Default backdrop animation is based on the Material Design swift-ease-out. +$backdrop-animation-duration: 400ms !default; +$backdrop-animation-timing-function: cubic-bezier(0.25, 0.8, 0.25, 1) !default; + + +@mixin cdk-overlay() { + .cdk-overlay-container, .cdk-global-overlay-wrapper { + // Disable events from being captured on the overlay container. + pointer-events: none; + + // The container should be the size of the viewport. + top: 0; + left: 0; + height: 100%; + width: 100%; + } + + // The overlay-container is an invisible element which contains all individual overlays. + .cdk-overlay-container { + position: fixed; + z-index: $cdk-z-index-overlay-container; + } + + // We use an extra wrapper element in order to use make the overlay itself a flex item. + // This makes centering the overlay easy without running into the subpixel rendering + // problems tied to using `transform` and without interfering with the other position + // strategies. + .cdk-global-overlay-wrapper { + display: flex; + position: absolute; + z-index: $cdk-z-index-overlay; + } + + // A single overlay pane. + .cdk-overlay-pane { + position: absolute; + pointer-events: auto; + box-sizing: border-box; + z-index: $cdk-z-index-overlay; + } + + .cdk-overlay-backdrop { + // TODO(jelbourn): reuse sidenav fullscreen mixin. + position: absolute; + top: 0; + bottom: 0; + left: 0; + right: 0; + + z-index: $cdk-z-index-overlay-backdrop; + pointer-events: auto; + -webkit-tap-highlight-color: transparent; + transition: opacity $backdrop-animation-duration $backdrop-animation-timing-function; + opacity: 0; + + &.cdk-overlay-backdrop-showing { + opacity: 0.48; + } + } + + .cdk-overlay-dark-backdrop { + background: $cdk-overlay-dark-backdrop-background; + } + + .cdk-overlay-transparent-backdrop { + background: none; + } + + // Used when disabling global scrolling. + .cdk-global-scrollblock { + position: fixed; + + // Necessary for the content not to lose its width. Note that we're using 100%, instead of + // 100vw, because 100vw includes the width plus the scrollbar, whereas 100% is the width + // that the element had before we made it `fixed`. + width: 100%; + + // Note: this will always add a scrollbar to whatever element it is on, which can + // potentially result in double scrollbars. It shouldn't be an issue, because we won't + // block scrolling on a page that doesn't have a scrollbar in the first place. + overflow-y: scroll; + } +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y-prebuilt.css ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y-prebuilt.css b/node_modules/@angular/cdk/a11y-prebuilt.css new file mode 100644 index 0000000..fc348fd --- /dev/null +++ b/node_modules/@angular/cdk/a11y-prebuilt.css @@ -0,0 +1 @@ +.cdk-visually-hidden{border:0;clip:rect(0 0 0 0);height:1px;margin:-1px;overflow:hidden;padding:0;position:absolute;width:1px} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y.d.ts b/node_modules/@angular/cdk/a11y.d.ts new file mode 100644 index 0000000..5f291cf --- /dev/null +++ b/node_modules/@angular/cdk/a11y.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export * from './a11y/index'; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y.metadata.json ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y.metadata.json b/node_modules/@angular/cdk/a11y.metadata.json new file mode 100644 index 0000000..90c7d2b --- /dev/null +++ b/node_modules/@angular/cdk/a11y.metadata.json @@ -0,0 +1,12 @@ +{ + "__symbolic": "module", + "version": 3, + "metadata": {}, + "exports": [ + { + "from": "./a11y/index" + } + ], + "flatModuleIndexRedirect": true, + "importAs": "@angular/cdk/a11y" +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/index.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/index.d.ts b/node_modules/@angular/cdk/a11y/index.d.ts new file mode 100644 index 0000000..5a30354 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/index.d.ts @@ -0,0 +1,8 @@ +/** + * @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 + */ +export * from './typings/index'; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/index.metadata.json ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/index.metadata.json b/node_modules/@angular/cdk/a11y/index.metadata.json new file mode 100644 index 0000000..c0d17e5 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/index.metadata.json @@ -0,0 +1,12 @@ +{ + "__symbolic": "module", + "version": 3, + "metadata": {}, + "exports": [ + { + "from": "./typings/index" + } + ], + "flatModuleIndexRedirect": true, + "importAs": "@angular/cdk/a11y" +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/package.json ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/package.json b/node_modules/@angular/cdk/a11y/package.json new file mode 100644 index 0000000..07200cd --- /dev/null +++ b/node_modules/@angular/cdk/a11y/package.json @@ -0,0 +1,7 @@ +{ + "name": "@angular/cdk/a11y", + "typings": "../a11y.d.ts", + "main": "../bundles/cdk-a11y.umd.js", + "module": "../esm5/a11y.es5.js", + "es2015": "../esm2015/a11y.js" +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/a11y-module.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/a11y-module.d.ts b/node_modules/@angular/cdk/a11y/typings/a11y-module.d.ts new file mode 100644 index 0000000..8d39e03 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/a11y-module.d.ts @@ -0,0 +1,2 @@ +export declare class A11yModule { +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/activedescendant-key-manager.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/activedescendant-key-manager.d.ts b/node_modules/@angular/cdk/a11y/typings/activedescendant-key-manager.d.ts new file mode 100644 index 0000000..2943560 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/activedescendant-key-manager.d.ts @@ -0,0 +1,25 @@ +/** + * @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 { ListKeyManager, ListKeyManagerOption } from './list-key-manager'; +/** + * This is the interface for highlightable items (used by the ActiveDescendantKeyManager). + * Each item must know how to style itself as active or inactive and whether or not it is + * currently disabled. + */ +export interface Highlightable extends ListKeyManagerOption { + setActiveStyles(): void; + setInactiveStyles(): void; +} +export declare class ActiveDescendantKeyManager<T> extends ListKeyManager<Highlightable & T> { + /** + * This method sets the active item to the item at the specified index. + * It also adds active styles to the newly active item and removes active + * styles from the previously active item. + */ + setActiveItem(index: number): void; +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/aria-describer.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/aria-describer.d.ts b/node_modules/@angular/cdk/a11y/typings/aria-describer.d.ts new file mode 100644 index 0000000..6477f0b --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/aria-describer.d.ts @@ -0,0 +1,51 @@ +/** + * @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 { Optional } from '@angular/core'; +import { Platform } from '@angular/cdk/platform'; +/** + * Interface used to register message elements and keep a count of how many registrations have + * the same message and the reference to the message element used for the aria-describedby. + */ +export interface RegisteredMessage { + messageElement: Element; + referenceCount: number; +} +/** ID used for the body container where all messages are appended. */ +export declare const MESSAGES_CONTAINER_ID = "cdk-describedby-message-container"; +/** ID prefix used for each created message element. */ +export declare const CDK_DESCRIBEDBY_ID_PREFIX = "cdk-describedby-message"; +/** Attribute given to each host element that is described by a message element. */ +export declare const CDK_DESCRIBEDBY_HOST_ATTRIBUTE = "cdk-describedby-host"; +/** + * Utility that creates visually hidden elements with a message content. Useful for elements that + * want to use aria-describedby to further describe themselves without adding additional visual + * content. + * @docs-private + */ +export declare class AriaDescriber { + private _platform; + constructor(_platform: Platform); + /** + * Adds to the host element an aria-describedby reference to a hidden element that contains + * the message. If the same message has already been registered, then it will reuse the created + * message element. + */ + describe(hostElement: Element, message: string): void; + /** Removes the host element's aria-describedby reference to the message element. */ + removeDescription(hostElement: Element, message: string): void; + /** Unregisters all created message elements and removes the message container. */ + ngOnDestroy(): void; +} +/** @docs-private */ +export declare function ARIA_DESCRIBER_PROVIDER_FACTORY(parentDispatcher: AriaDescriber, platform: Platform): AriaDescriber; +/** @docs-private */ +export declare const ARIA_DESCRIBER_PROVIDER: { + provide: typeof AriaDescriber; + deps: (Optional[] | typeof Platform)[]; + useFactory: (parentDispatcher: AriaDescriber, platform: Platform) => AriaDescriber; +}; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/aria-reference.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/aria-reference.d.ts b/node_modules/@angular/cdk/a11y/typings/aria-reference.d.ts new file mode 100644 index 0000000..3e39404 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/aria-reference.d.ts @@ -0,0 +1,15 @@ +/** + * Adds the given ID to the specified ARIA attribute on an element. + * Used for attributes such as aria-labelledby, aria-owns, etc. + */ +export declare function addAriaReferencedId(el: Element, attr: string, id: string): void; +/** + * Removes the given ID from the specified ARIA attribute on an element. + * Used for attributes such as aria-labelledby, aria-owns, etc. + */ +export declare function removeAriaReferencedId(el: Element, attr: string, id: string): void; +/** + * Gets the list of IDs referenced by the given ARIA attribute on an element. + * Used for attributes such as aria-labelledby, aria-owns, etc. + */ +export declare function getAriaReferenceIds(el: Element, attr: string): string[]; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/fake-mousedown.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/fake-mousedown.d.ts b/node_modules/@angular/cdk/a11y/typings/fake-mousedown.d.ts new file mode 100644 index 0000000..ac3b375 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/fake-mousedown.d.ts @@ -0,0 +1,15 @@ +/** + * @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 + */ +/** + * Screenreaders will often fire fake mousedown events when a focusable element + * is activated using the keyboard. We can typically distinguish between these faked + * mousedown events and real mousedown events using the "buttons" property. While + * real mousedowns will indicate the mouse button that was pressed (e.g. "1" for + * the left mouse button), faked mousedowns will usually set the property value to 0. + */ +export declare function isFakeMousedownFromScreenReader(event: MouseEvent): boolean; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/focus-key-manager.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/focus-key-manager.d.ts b/node_modules/@angular/cdk/a11y/typings/focus-key-manager.d.ts new file mode 100644 index 0000000..ae1dc94 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/focus-key-manager.d.ts @@ -0,0 +1,23 @@ +/** + * @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 { ListKeyManager, ListKeyManagerOption } from './list-key-manager'; +/** + * This is the interface for focusable items (used by the FocusKeyManager). + * Each item must know how to focus itself, whether or not it is currently disabled + * and be able to supply it's label. + */ +export interface FocusableOption extends ListKeyManagerOption { + focus(): void; +} +export declare class FocusKeyManager<T> extends ListKeyManager<FocusableOption & T> { + /** + * This method sets the active item to the item at the specified index. + * It also adds focuses the newly active item. + */ + setActiveItem(index: number): void; +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/focus-monitor.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/focus-monitor.d.ts b/node_modules/@angular/cdk/a11y/typings/focus-monitor.d.ts new file mode 100644 index 0000000..463d67a --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/focus-monitor.d.ts @@ -0,0 +1,106 @@ +/** + * @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 { Platform } from '@angular/cdk/platform'; +import { ElementRef, EventEmitter, NgZone, OnDestroy, Optional, Renderer2 } from '@angular/core'; +import { Observable } from 'rxjs/Observable'; +export declare const TOUCH_BUFFER_MS = 650; +export declare type FocusOrigin = 'touch' | 'mouse' | 'keyboard' | 'program' | null; +/** Monitors mouse and keyboard events to determine the cause of focus events. */ +export declare class FocusMonitor { + private _ngZone; + private _platform; + /** The focus origin that the next focus event is a result of. */ + private _origin; + /** The FocusOrigin of the last focus event tracked by the FocusMonitor. */ + private _lastFocusOrigin; + /** Whether the window has just been focused. */ + private _windowFocused; + /** The target of the last touch event. */ + private _lastTouchTarget; + /** The timeout id of the touch timeout, used to cancel timeout later. */ + private _touchTimeout; + /** Weak map of elements being monitored to their info. */ + private _elementInfo; + constructor(_ngZone: NgZone, _platform: Platform); + /** + * Monitors focus on an element and applies appropriate CSS classes. + * @param element The element to monitor + * @param renderer The renderer to use to apply CSS classes to the element. + * @param checkChildren Whether to count the element as focused when its children are focused. + * @returns An observable that emits when the focus state of the element changes. + * When the element is blurred, null will be emitted. + */ + monitor(element: HTMLElement, renderer: Renderer2, checkChildren: boolean): Observable<FocusOrigin>; + /** + * Stops monitoring an element and removes all focus classes. + * @param element The element to stop monitoring. + */ + stopMonitoring(element: HTMLElement): void; + /** + * Focuses the element via the specified focus origin. + * @param element The element to focus. + * @param origin The focus origin. + */ + focusVia(element: HTMLElement, origin: FocusOrigin): void; + /** Register necessary event listeners on the document and window. */ + private _registerDocumentEvents(); + /** + * Sets the focus classes on the element based on the given focus origin. + * @param element The element to update the classes on. + * @param origin The focus origin. + */ + private _setClasses(element, origin?); + /** + * Sets the origin and schedules an async function to clear it at the end of the event queue. + * @param origin The origin to set. + */ + private _setOriginForCurrentEventQueue(origin); + /** + * Checks whether the given focus event was caused by a touchstart event. + * @param event The focus event to check. + * @returns Whether the event was caused by a touch. + */ + private _wasCausedByTouch(event); + /** + * Handles focus events on a registered element. + * @param event The focus event. + * @param element The monitored element. + */ + private _onFocus(event, element); + /** + * Handles blur events on a registered element. + * @param event The blur event. + * @param element The monitored element. + */ + _onBlur(event: FocusEvent, element: HTMLElement): void; +} +/** + * Directive that determines how a particular element was focused (via keyboard, mouse, touch, or + * programmatically) and adds corresponding classes to the element. + * + * There are two variants of this directive: + * 1) cdkMonitorElementFocus: does not consider an element to be focused if one of its children is + * focused. + * 2) cdkMonitorSubtreeFocus: considers an element focused if it or any of its children are focused. + */ +export declare class CdkMonitorFocus implements OnDestroy { + private _elementRef; + private _focusMonitor; + private _monitorSubscription; + cdkFocusChange: EventEmitter<FocusOrigin>; + constructor(_elementRef: ElementRef, _focusMonitor: FocusMonitor, renderer: Renderer2); + ngOnDestroy(): void; +} +/** @docs-private */ +export declare function FOCUS_MONITOR_PROVIDER_FACTORY(parentDispatcher: FocusMonitor, ngZone: NgZone, platform: Platform): FocusMonitor; +/** @docs-private */ +export declare const FOCUS_MONITOR_PROVIDER: { + provide: typeof FocusMonitor; + deps: (Optional[] | typeof Platform | typeof NgZone)[]; + useFactory: (parentDispatcher: FocusMonitor, ngZone: NgZone, platform: Platform) => FocusMonitor; +}; http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/focus-trap.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/focus-trap.d.ts b/node_modules/@angular/cdk/a11y/typings/focus-trap.d.ts new file mode 100644 index 0000000..f16af28 --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/focus-trap.d.ts @@ -0,0 +1,120 @@ +/** + * @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 { ElementRef, NgZone, OnDestroy, AfterContentInit } from '@angular/core'; +import { Platform } from '@angular/cdk/platform'; +import { InteractivityChecker } from './interactivity-checker'; +/** + * Class that allows for trapping focus within a DOM element. + * + * NOTE: This class currently uses a very simple (naive) approach to focus trapping. + * It assumes that the tab order is the same as DOM order, which is not necessarily true. + * Things like tabIndex > 0, flex `order`, and shadow roots can cause to two to misalign. + * This will be replaced with a more intelligent solution before the library is considered stable. + */ +export declare class FocusTrap { + private _element; + private _platform; + private _checker; + private _ngZone; + private _startAnchor; + private _endAnchor; + /** Whether the focus trap is active. */ + enabled: boolean; + private _enabled; + constructor(_element: HTMLElement, _platform: Platform, _checker: InteractivityChecker, _ngZone: NgZone, deferAnchors?: boolean); + /** Destroys the focus trap by cleaning up the anchors. */ + destroy(): void; + /** + * Inserts the anchors into the DOM. This is usually done automatically + * in the constructor, but can be deferred for cases like directives with `*ngIf`. + */ + attachAnchors(): void; + /** + * Waits for the zone to stabilize, then either focuses the first element that the + * user specified, or the first tabbable element. + * @returns Returns a promise that resolves with a boolean, depending + * on whether focus was moved successfuly. + */ + focusInitialElementWhenReady(): Promise<boolean>; + /** + * Waits for the zone to stabilize, then focuses + * the first tabbable element within the focus trap region. + * @returns Returns a promise that resolves with a boolean, depending + * on whether focus was moved successfuly. + */ + focusFirstTabbableElementWhenReady(): Promise<boolean>; + /** + * Waits for the zone to stabilize, then focuses + * the last tabbable element within the focus trap region. + * @returns Returns a promise that resolves with a boolean, depending + * on whether focus was moved successfuly. + */ + focusLastTabbableElementWhenReady(): Promise<boolean>; + /** + * Get the specified boundary element of the trapped region. + * @param bound The boundary to get (start or end of trapped region). + * @returns The boundary element. + */ + private _getRegionBoundary(bound); + /** + * Focuses the element that should be focused when the focus trap is initialized. + * @returns Returns whether focus was moved successfuly. + */ + focusInitialElement(): boolean; + /** + * Focuses the first tabbable element within the focus trap region. + * @returns Returns whether focus was moved successfuly. + */ + focusFirstTabbableElement(): boolean; + /** + * Focuses the last tabbable element within the focus trap region. + * @returns Returns whether focus was moved successfuly. + */ + focusLastTabbableElement(): boolean; + /** Get the first tabbable element from a DOM subtree (inclusive). */ + private _getFirstTabbableElement(root); + /** Get the last tabbable element from a DOM subtree (inclusive). */ + private _getLastTabbableElement(root); + /** Creates an anchor element. */ + private _createAnchor(); + /** Executes a function when the zone is stable. */ + private _executeOnStable(fn); +} +/** Factory that allows easy instantiation of focus traps. */ +export declare class FocusTrapFactory { + private _checker; + private _platform; + private _ngZone; + constructor(_checker: InteractivityChecker, _platform: Platform, _ngZone: NgZone); + create(element: HTMLElement, deferAnchors?: boolean): FocusTrap; +} +/** + * Directive for trapping focus within a region. + * @deprecated + */ +export declare class FocusTrapDeprecatedDirective implements OnDestroy, AfterContentInit { + private _elementRef; + private _focusTrapFactory; + focusTrap: FocusTrap; + /** Whether the focus trap is active. */ + disabled: boolean; + constructor(_elementRef: ElementRef, _focusTrapFactory: FocusTrapFactory); + ngOnDestroy(): void; + ngAfterContentInit(): void; +} +/** Directive for trapping focus within a region. */ +export declare class FocusTrapDirective implements OnDestroy, AfterContentInit { + private _elementRef; + private _focusTrapFactory; + focusTrap: FocusTrap; + /** Whether the focus trap is active. */ + enabled: boolean; + constructor(_elementRef: ElementRef, _focusTrapFactory: FocusTrapFactory); + ngOnDestroy(): void; + ngAfterContentInit(): void; +} http://git-wip-us.apache.org/repos/asf/nifi-fds/blob/90759b86/node_modules/@angular/cdk/a11y/typings/index.d.ts ---------------------------------------------------------------------- diff --git a/node_modules/@angular/cdk/a11y/typings/index.d.ts b/node_modules/@angular/cdk/a11y/typings/index.d.ts new file mode 100644 index 0000000..e5daacf --- /dev/null +++ b/node_modules/@angular/cdk/a11y/typings/index.d.ts @@ -0,0 +1,4 @@ +/** + * Generated bundle index. Do not edit. + */ +export * from './public-api';
