@angular/forms - npm Package Compare versions

Comparing version 2.0.0-rc.7 to 2.0.0

README.md

package.json

		{
		"name": "@angular/forms",
		"version": "2.0.0-rc.7",
		"description": "Angular 2 forms",
		"version": "2.0.0",
		"description": "Angular - directives and services for creating forms",
		"main": "bundles/forms.umd.js",
		@@ -11,4 +11,4 @@ "module": "index.js",
		"peerDependencies": {
		"@angular/core": "^2.0.0-rc.7",
		"@angular/common": "^2.0.0-rc.7"
		"@angular/core": "^2.0.0",
		"@angular/common": "^2.0.0"
		},
		@@ -15,0 +15,0 @@ "repository": {

src/form_builder.d.ts

		import { AsyncValidatorFn, ValidatorFn } from './directives/validators';
		import { FormArray, FormControl, FormGroup } from './model';
		/**
		* Creates a form object from a user-specified configuration.
		* @whatItDoes Creates an {@link AbstractControl} from a user-specified configuration.
		*
		* ```typescript
		* @Component({
		* selector: 'my-app',
		* template: `
		* <form [formGroup]="loginForm">
		* <p>Login <input formControlName="login"></p>
		* <div formGroupName="passwordRetry">
		* <p>Password <input type="password" formControlName="password"></p>
		* <p>Confirm password <input type="password" formControlName="passwordConfirmation"></p>
		* </div>
		* </form>
		* <h3>Form value:</h3>
		* <pre>{{value}}</pre>
		* `,
		* directives: [REACTIVE_FORM_DIRECTIVES]
		* })
		* export class App {
		* loginForm: FormGroup;
		* It is essentially syntactic sugar that shortens the `new FormGroup()`,
		* `new FormControl()`, and `new FormArray()` boilerplate that can build up in larger
		* forms.
		*
		* constructor(builder: FormBuilder) {
		* this.loginForm = builder.group({
		* login: ["", Validators.required],
		* passwordRetry: builder.group({
		* password: ["", Validators.required],
		* passwordConfirmation: ["", Validators.required, asyncValidator]
		* })
		* });
		* }
		* @howToUse
		*
		* get value(): string {
		* return JSON.stringify(this.loginForm.value, null, 2);
		* }
		* }
		* ```
		* To use, inject `FormBuilder` into your component class. You can then call its methods
		* directly.
		*
		* {@example forms/ts/formBuilder/form_builder_example.ts region='Component'}
		*
		* * npm package: `@angular/forms`
		*
		* * NgModule: {@link ReactiveFormsModule}
		*
		* @stable
		@@ -46,3 +26,3 @@ */
		* Construct a new {@link FormGroup} with the given map of configuration.
		* Valid keys for the `extra` parameter map are `optionals` and `validator`.
		* Valid keys for the `extra` parameter map are `validator` and `asyncValidator`.
		*
		@@ -59,6 +39,10 @@ * See the {@link FormGroup} constructor for more details.
		* `asyncValidator`.
		*
		* `formState` can either be a standalone value for the form control or an object
		* that contains both a value and a disabled status.
		*
		*/
		control(formState: Object, validator?: ValidatorFn \| ValidatorFn[], asyncValidator?: AsyncValidatorFn \| AsyncValidatorFn[]): FormControl;
		/**
		* Construct an array of {@link FormControl}s from the given `controlsConfig` array of
		* Construct a {@link FormArray} from the given `controlsConfig` array of
		* configuration, with the given optional `validator` and `asyncValidator`.
		@@ -65,0 +49,0 @@ */

src/form_builder.js

		@@ -13,39 +13,19 @@ /**
		/**
		* Creates a form object from a user-specified configuration.
		* @whatItDoes Creates an {@link AbstractControl} from a user-specified configuration.
		*
		* ```typescript
		* @Component({
		* selector: 'my-app',
		* template: `
		* <form [formGroup]="loginForm">
		* <p>Login <input formControlName="login"></p>
		* <div formGroupName="passwordRetry">
		* <p>Password <input type="password" formControlName="password"></p>
		* <p>Confirm password <input type="password" formControlName="passwordConfirmation"></p>
		* </div>
		* </form>
		* <h3>Form value:</h3>
		* <pre>{{value}}</pre>
		* `,
		* directives: [REACTIVE_FORM_DIRECTIVES]
		* })
		* export class App {
		* loginForm: FormGroup;
		* It is essentially syntactic sugar that shortens the `new FormGroup()`,
		* `new FormControl()`, and `new FormArray()` boilerplate that can build up in larger
		* forms.
		*
		* constructor(builder: FormBuilder) {
		* this.loginForm = builder.group({
		* login: ["", Validators.required],
		* passwordRetry: builder.group({
		* password: ["", Validators.required],
		* passwordConfirmation: ["", Validators.required, asyncValidator]
		* })
		* });
		* }
		* @howToUse
		*
		* get value(): string {
		* return JSON.stringify(this.loginForm.value, null, 2);
		* }
		* }
		* ```
		* To use, inject `FormBuilder` into your component class. You can then call its methods
		* directly.
		*
		* {@example forms/ts/formBuilder/form_builder_example.ts region='Component'}
		*
		* * npm package: `@angular/forms`
		*
		* * NgModule: {@link ReactiveFormsModule}
		*
		* @stable
		@@ -58,3 +38,3 @@ */
		* Construct a new {@link FormGroup} with the given map of configuration.
		* Valid keys for the `extra` parameter map are `optionals` and `validator`.
		* Valid keys for the `extra` parameter map are `validator` and `asyncValidator`.
		*
		@@ -73,2 +53,6 @@ * See the {@link FormGroup} constructor for more details.
		* `asyncValidator`.
		*
		* `formState` can either be a standalone value for the form control or an object
		* that contains both a value and a disabled status.
		*
		*/
		@@ -81,3 +65,3 @@ FormBuilder.prototype.control = function (formState, validator, asyncValidator) {
		/**
		* Construct an array of {@link FormControl}s from the given `controlsConfig` array of
		* Construct a {@link FormArray} from the given `controlsConfig` array of
		* configuration, with the given optional `validator` and `asyncValidator`.
		@@ -84,0 +68,0 @@ */

554

src/model.d.ts

		@@ -23,2 +23,10 @@ import { AsyncValidatorFn, ValidatorFn } from './directives/validators';
		/**
		* @whatItDoes This is the base class for {@link FormControl}, {@link FormGroup}, and
		* {@link FormArray}.
		*
		* It provides some of the shared behavior that all controls and groups of controls have, like
		* running validators, calculating status, and resetting state. It also defines the properties
		* that are shared between all sub-classes, like `value`, `valid`, and `dirty`. It shouldn't be
		* instantiated directly.
		*
		* @stable
		@@ -38,40 +46,166 @@ */
		constructor(validator: ValidatorFn, asyncValidator: AsyncValidatorFn);
		/**
		* The value of the control.
		*/
		value: any;
		/**
		* The validation status of the control. There are four possible
		* validation statuses:
		*
		* * VALID: control has passed all validation checks
		* * INVALID: control has failed at least one validation check
		* * PENDING: control is in the midst of conducting a validation check
		* * DISABLED: control is exempt from validation checks
		*
		* These statuses are mutually exclusive, so a control cannot be
		* both valid AND invalid or invalid AND disabled.
		*/
		status: string;
		/**
		* A control is `valid` when its `status === VALID`.
		*
		* In order to have this status, the control must have passed all its
		* validation checks.
		*/
		valid: boolean;
		/**
		* A control is `invalid` when its `status === INVALID`.
		*
		* In order to have this status, the control must have failed
		* at least one of its validation checks.
		*/
		invalid: boolean;
		/**
		* Returns the errors of this control.
		* A control is `pending` when its `status === PENDING`.
		*
		* In order to have this status, the control must be in the
		* middle of conducting a validation check.
		*/
		pending: boolean;
		/**
		* A control is `disabled` when its `status === DISABLED`.
		*
		* Disabled controls are exempt from validation checks and
		* are not included in the aggregate value of their ancestor
		* controls.
		*/
		disabled: boolean;
		/**
		* A control is `enabled` as long as its `status !== DISABLED`.
		*
		* In other words, it has a status of `VALID`, `INVALID`, or
		* `PENDING`.
		*/
		enabled: boolean;
		/**
		* Returns any errors generated by failing validation. If there
		* are no errors, it will return null.
		*/
		errors: {
		[key: string]: any;
		};
		/**
		* A control is `pristine` if the user has not yet changed
		* the value in the UI.
		*
		* Note that programmatic changes to a control's value will
		* not mark it dirty.
		*/
		pristine: boolean;
		/**
		* A control is `dirty` if the user has changed the value
		* in the UI.
		*
		* Note that programmatic changes to a control's value will
		* not mark it dirty.
		*/
		dirty: boolean;
		/**
		* A control is marked `touched` once the user has triggered
		* a `blur` event on it.
		*/
		touched: boolean;
		/**
		* A control is `untouched` if the user has not yet triggered
		* a `blur` event on it.
		*/
		untouched: boolean;
		/**
		* Emits an event every time the value of the control changes, in
		* the UI or programmatically.
		*/
		valueChanges: Observable<any>;
		/**
		* Emits an event every time the validation status of the control
		* is re-calculated.
		*/
		statusChanges: Observable<any>;
		pending: boolean;
		disabled: boolean;
		enabled: boolean;
		/**
		* Sets the synchronous validators that are active on this control. Calling
		* this will overwrite any existing sync validators.
		*/
		setValidators(newValidator: ValidatorFn \| ValidatorFn[]): void;
		/**
		* Sets the async validators that are active on this control. Calling this
		* will overwrite any existing async validators.
		*/
		setAsyncValidators(newValidator: AsyncValidatorFn \| AsyncValidatorFn[]): void;
		/**
		* Empties out the sync validator list.
		*/
		clearValidators(): void;
		/**
		* Empties out the async validator list.
		*/
		clearAsyncValidators(): void;
		setValidators(newValidator: ValidatorFn \| ValidatorFn[]): void;
		clearValidators(): void;
		/**
		* Marks the control as `touched`.
		*
		* This will also mark all direct ancestors as `touched` to maintain
		* the model.
		*/
		markAsTouched({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Marks the control as `untouched`.
		*
		* If the control has any children, it will also mark all children as `untouched`
		* to maintain the model, and re-calculate the `touched` status of all parent
		* controls.
		*/
		markAsUntouched({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Marks the control as `dirty`.
		*
		* This will also mark all direct ancestors as `dirty` to maintain
		* the model.
		*/
		markAsDirty({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Marks the control as `pristine`.
		*
		* If the control has any children, it will also mark all children as `pristine`
		* to maintain the model, and re-calculate the `pristine` status of all parent
		* controls.
		*/
		markAsPristine({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		markAsUntouched({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Marks the control as `pending`.
		*/
		markAsPending({onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Disables the control. This means the control will be exempt from validation checks and
		* excluded from the aggregate value of any parent. Its status is `DISABLED`.
		*
		* If the control has children, all children will be disabled to maintain the model.
		*/
		disable({onlySelf, emitEvent}?: {
		@@ -81,2 +215,9 @@ onlySelf?: boolean;
		}): void;
		/**
		* Enables the control. This means the control will be included in validation checks and
		* the aggregate value of its parent. Its status is re-calculated based on its value and
		* its validators.
		*
		* If the control has children, all children will be enabled.
		*/
		enable({onlySelf, emitEvent}?: {
		@@ -88,5 +229,19 @@ onlySelf?: boolean;
		setParent(parent: FormGroup \| FormArray): void;
		/**
		* Sets the value of the control. Abstract method (implemented in sub-classes).
		*/
		abstract setValue(value: any, options?: Object): void;
		/**
		* Patches the value of the control. Abstract method (implemented in sub-classes).
		*/
		abstract patchValue(value: any, options?: Object): void;
		/**
		* Resets the control. Abstract method (implemented in sub-classes).
		*/
		abstract reset(value?: any, options?: Object): void;
		/**
		* Re-calculates the value and validation status of the control.
		*
		* By default, it will also update the value and validity of its ancestors.
		*/
		updateValueAndValidity({onlySelf, emitEvent}?: {
		@@ -103,10 +258,10 @@ onlySelf?: boolean;
		*
		* This is used when validations are run not automatically, but manually by the user.
		* This is used when validations are run manually by the user, rather than automatically.
		*
		* Calling `setErrors` will also update the validity of the parent control.
		*
		* ## Usage
		* ### Example
		*
		* ```
		* var login = new FormControl("someLogin");
		* const login = new FormControl("someLogin");
		* login.setErrors({
		@@ -119,3 +274,3 @@ * "notUnique": true
		*
		* login.updateValue("someOtherLogin");
		* login.setValue("someOtherLogin");
		*
		@@ -130,5 +285,33 @@ * expect(login.valid).toEqual(true);
		}): void;
		/**
		* Retrieves a child control given the control's name or path.
		*
		* Paths can be passed in as an array or a string delimited by a dot.
		*
		* To get a control nested within a `person` sub-group:
		*
		* * `this.form.get('person.name');`
		*
		* -OR-
		*
		* * `this.form.get(['person', 'name']);`
		*/
		get(path: Array<string \| number> \| string): AbstractControl;
		/**
		* Returns true if the control with the given path has the error specified. Otherwise
		* returns null or undefined.
		*
		* If no path is given, it checks for the error on the present control.
		*/
		getError(errorCode: string, path?: string[]): any;
		/**
		* Returns true if the control with the given path has the error specified. Otherwise
		* returns false.
		*
		* If no path is given, it checks for the error on the present control.
		*/
		hasError(errorCode: string, path?: string[]): boolean;
		/**
		* Retrieves the top-level ancestor of this control.
		*/
		root: AbstractControl;
		@@ -138,17 +321,40 @@ private _calculateStatus();
		/**
		* Defines a part of a form that cannot be divided into other controls. `FormControl`s have values
		* and
		* validation state, which is determined by an optional validation function.
		* @whatItDoes Tracks the value and validation status of an individual form control.
		*
		* `FormControl` is one of the three fundamental building blocks used to define forms in Angular,
		* along
		* with {@link FormGroup} and {@link FormArray}.
		* It is one of the three fundamental building blocks of Angular forms, along with
		* {@link FormGroup} and {@link FormArray}.
		*
		* ## Usage
		* @howToUse
		*
		* By default, a `FormControl` is created for every `<input>` or other form component.
		* With {@link FormControlDirective} or {@link FormGroupDirective} an existing {@link FormControl}
		* can be bound to a DOM element instead. This `FormControl` can be configured with a custom
		* validation function.
		* When instantiating a {@link FormControl}, you can pass in an initial value as the
		* first argument. Example:
		*
		* ```ts
		* const ctrl = new FormControl('some value');
		* console.log(ctrl.value); // 'some value'
		*```
		*
		* You can also initialize the control with a form state object on instantiation,
		* which includes both the value and whether or not the control is disabled.
		*
		* ```ts
		* const ctrl = new FormControl({value: 'n/a', disabled: true});
		* console.log(ctrl.value); // 'n/a'
		* console.log(ctrl.status); // 'DISABLED'
		* ```
		*
		* To include a sync validator (or an array of sync validators) with the control,
		* pass it in as the second argument. Async validators are also supported, but
		* have to be passed in separately as the third arg.
		*
		* ```ts
		* const ctrl = new FormControl('', Validators.required);
		* console.log(ctrl.value); // ''
		* console.log(ctrl.status); // 'INVALID'
		* ```
		*
		* See its superclass, {@link AbstractControl}, for more properties and methods.
		*
		* * npm package: `@angular/forms`
		*
		* @stable
		@@ -162,6 +368,8 @@ */
		* If `onlySelf` is `true`, this change will only affect the validation of this `FormControl`
		* and not its parent component. If `emitEvent` is `true`, this change will cause a
		* `valueChanges` event on the `FormControl` to be emitted. Both of these options default to
		* `false`.
		* and not its parent component. This defaults to false.
		*
		* If `emitEvent` is `true`, this
		* change will cause a `valueChanges` event on the `FormControl` to be emitted. This defaults
		* to true (as it falls through to `updateValueAndValidity`).
		*
		* If `emitModelToViewChange` is `true`, the view will be notified about the new value
		@@ -181,4 +389,7 @@ * via an `onChange` event. This is the default behavior if `emitModelToViewChange` is not
		/**
		* This function is functionally the same as updateValue() at this level. It exists for
		* symmetry with patchValue() on FormGroups and FormArrays, where it does behave differently.
		* Patches the value of a control.
		*
		* This function is functionally the same as {@link FormControl.setValue} at this level.
		* It exists for symmetry with {@link FormGroup.patchValue} on `FormGroups` and `FormArrays`,
		* where it does behave differently.
		*/
		@@ -191,2 +402,30 @@ patchValue(value: any, options?: {
		}): void;
		/**
		* Resets the form control. This means by default:
		*
		* * it is marked as `pristine`
		* * it is marked as `untouched`
		* * value is set to null
		*
		* You can also reset to a specific form state by passing through a standalone
		* value or a form state object that contains both a value and a disabled state
		* (these are the only two properties that cannot be calculated).
		*
		* Ex:
		*
		* ```ts
		* this.control.reset('Nancy');
		*
		* console.log(this.control.value); // 'Nancy'
		* ```
		*
		* OR
		*
		* ```
		* this.control.reset({value: 'Nancy', disabled: true});
		*
		* console.log(this.control.value); // 'Nancy'
		* console.log(this.control.status); // 'DISABLED'
		* ```
		*/
		reset(formState?: any, {onlySelf}?: {
		@@ -206,14 +445,51 @@ onlySelf?: boolean;
		/**
		* Defines a part of a form, of fixed length, that can contain other controls.
		* @whatItDoes Tracks the value and validity state of a group of {@link FormControl}
		* instances.
		*
		* A `FormGroup` aggregates the values of each {@link FormControl} in the group.
		* The status of a `FormGroup` depends on the status of its children.
		* If one of the controls in a group is invalid, the entire group is invalid.
		* Similarly, if a control changes its value, the entire group changes as well.
		* A `FormGroup` aggregates the values of each child {@link FormControl} into one object,
		* with each control name as the key. It calculates its status by reducing the statuses
		* of its children. For example, if one of the controls in a group is invalid, the entire
		* group becomes invalid.
		*
		* `FormGroup` is one of the three fundamental building blocks used to define forms in Angular,
		* along with {@link FormControl} and {@link FormArray}. {@link FormArray} can also contain other
		* controls, but is of variable length.
		* along with {@link FormControl} and {@link FormArray}.
		*
		* @howToUse
		*
		* When instantiating a {@link FormGroup}, pass in a collection of child controls as the first
		* argument. The key for each child will be the name under which it is registered.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl('Nancy', Validators.minLength(2)),
		* last: new FormControl('Drew'),
		* });
		*
		* console.log(form.value); // {first: 'Nancy', last; 'Drew'}
		* console.log(form.status); // 'VALID'
		* ```
		*
		* You can also include group-level validators as the second arg, or group-level async
		* validators as the third arg. These come in handy when you want to perform validation
		* that considers the value of more than one child control.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* password: new FormControl('', Validators.minLength(2)),
		* passwordConfirm: new FormControl('', Validators.minLength(2)),
		* }, passwordMatchValidator);
		*
		*
		* function passwordMatchValidator(g: FormGroup) {
		* return g.get('password').value === g.get('passwordConfirm').value
		* ? null : {'mismatch': true};
		* }
		* ```
		*
		* * npm package: `@angular/forms`
		*
		* @stable
		@@ -229,3 +505,6 @@ */
		/**
		* Register a control with the group's list of controls.
		* Registers a control with the group's list of controls.
		*
		* This method does not update value or validity of the control, so for
		* most cases you'll want to use {@link FormGroup.addControl} instead.
		*/
		@@ -246,5 +525,30 @@ registerControl(name: string, control: AbstractControl): AbstractControl;
		/**
		* Check whether there is a control with the given name in the group.
		* Check whether there is an enabled control with the given name in the group.
		*
		* It will return false for disabled controls. If you'd like to check for
		* existence in the group only, use {@link AbstractControl.get} instead.
		*/
		contains(controlName: string): boolean;
		/**
		* Sets the value of the {@link FormGroup}. It accepts an object that matches
		* the structure of the group, with control names as keys.
		*
		* This method performs strict checks, so it will throw an error if you try
		* to set the value of a control that doesn't exist or if you exclude the
		* value of a control.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl(),
		* last: new FormControl()
		* });
		* console.log(form.value); // {first: null, last: null}
		*
		* form.setValue({first: 'Nancy', last: 'Drew'});
		* console.log(form.value); // {first: 'Nancy', last: 'Drew'}
		*
		* ```
		*/
		setValue(value: {
		@@ -255,2 +559,23 @@ [key: string]: any;
		}): void;
		/**
		* Patches the value of the {@link FormGroup}. It accepts an object with control
		* names as keys, and will do its best to match the values to the correct controls
		* in the group.
		*
		* It accepts both super-sets and sub-sets of the group without throwing an error.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl(),
		* last: new FormControl()
		* });
		* console.log(form.value); // {first: null, last: null}
		*
		* form.patchValue({first: 'Nancy'});
		* console.log(form.value); // {first: 'Nancy', last: null}
		*
		* ```
		*/
		patchValue(value: {
		@@ -261,21 +586,79 @@ [key: string]: any;
		}): void;
		/**
		* Resets the {@link FormGroup}. This means by default:
		*
		* * The group and all descendants are marked `pristine`
		* * The group and all descendants are marked `untouched`
		* * The value of all descendants will be null or null maps
		*
		* You can also reset to a specific form state by passing in a map of states
		* that matches the structure of your form, with control names as keys. The state
		* can be a standalone value or a form state object with both a value and a disabled
		* status.
		*
		* ### Example
		*
		* ```ts
		* this.form.reset({first: 'name', last; 'last name'});
		*
		* console.log(this.form.value); // {first: 'name', last: 'last name'}
		* ```
		*
		* - OR -
		*
		* ```
		* this.form.reset({
		* first: {value: 'name', disabled: true},
		* last: 'last'
		* });
		*
		* console.log(this.form.value); // {first: 'name', last: 'last name'}
		* console.log(this.form.get('first').status); // 'DISABLED'
		* ```
		*/
		reset(value?: any, {onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* The aggregate value of the {@link FormGroup}, including any disabled controls.
		*
		* If you'd like to include all values regardless of disabled status, use this method.
		* Otherwise, the `value` property is the best way to get the value of the group.
		*/
		getRawValue(): Object;
		}
		/**
		* Defines a part of a form, of variable length, that can contain other controls.
		* @whatItDoes Tracks the value and validity state of an array of {@link FormControl}
		* instances.
		*
		* A `FormArray` aggregates the values of each {@link FormControl} in the group.
		* The status of a `FormArray` depends on the status of its children.
		* If one of the controls in a group is invalid, the entire array is invalid.
		* Similarly, if a control changes its value, the entire array changes as well.
		* A `FormArray` aggregates the values of each child {@link FormControl} into an array.
		* It calculates its status by reducing the statuses of its children. For example, if one of
		* the controls in a `FormArray` is invalid, the entire array becomes invalid.
		*
		* `FormArray` is one of the three fundamental building blocks used to define forms in Angular,
		* along with {@link FormControl} and {@link FormGroup}. {@link FormGroup} can also contain
		* other controls, but is of fixed length.
		* along with {@link FormControl} and {@link FormGroup}.
		*
		* ## Adding or removing controls
		* @howToUse
		*
		* When instantiating a {@link FormArray}, pass in an array of child controls as the first
		* argument.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl('Nancy', Validators.minLength(2)),
		* new FormControl('Drew'),
		* ]);
		*
		* console.log(arr.value); // ['Nancy', 'Drew']
		* console.log(arr.status); // 'VALID'
		* ```
		*
		* You can also include array-level validators as the second arg, or array-level async
		* validators as the third arg. These come in handy when you want to perform validation
		* that considers the value of more than one child control.
		*
		* ### Adding or removing controls
		*
		* To change the controls in the array, use the `push`, `insert`, or `removeAt` methods
		@@ -287,2 +670,3 @@ * in `FormArray` itself. These methods ensure the controls are properly tracked in the
		*
		* * npm package: `@angular/forms`
		*
		@@ -318,13 +702,91 @@ * @stable
		length: number;
		/**
		* Sets the value of the {@link FormArray}. It accepts an array that matches
		* the structure of the control.
		*
		* This method performs strict checks, so it will throw an error if you try
		* to set the value of a control that doesn't exist or if you exclude the
		* value of a control.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl(),
		* new FormControl()
		* ]);
		* console.log(arr.value); // [null, null]
		*
		* arr.setValue(['Nancy', 'Drew']);
		* console.log(arr.value); // ['Nancy', 'Drew']
		* ```
		*/
		setValue(value: any[], {onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Patches the value of the {@link FormArray}. It accepts an array that matches the
		* structure of the control, and will do its best to match the values to the correct
		* controls in the group.
		*
		* It accepts both super-sets and sub-sets of the array without throwing an error.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl(),
		* new FormControl()
		* ]);
		* console.log(arr.value); // [null, null]
		*
		* arr.patchValue(['Nancy']);
		* console.log(arr.value); // ['Nancy', null]
		* ```
		*/
		patchValue(value: any[], {onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* Resets the {@link FormArray}. This means by default:
		*
		* * The array and all descendants are marked `pristine`
		* * The array and all descendants are marked `untouched`
		* * The value of all descendants will be null or null maps
		*
		* You can also reset to a specific form state by passing in an array of states
		* that matches the structure of the control. The state can be a standalone value
		* or a form state object with both a value and a disabled status.
		*
		* ### Example
		*
		* ```ts
		* this.arr.reset(['name', 'last name']);
		*
		* console.log(this.arr.value); // ['name', 'last name']
		* ```
		*
		* - OR -
		*
		* ```
		* this.arr.reset([
		* {value: 'name', disabled: true},
		* 'last'
		* ]);
		*
		* console.log(this.arr.value); // ['name', 'last name']
		* console.log(this.arr.get(0).status); // 'DISABLED'
		* ```
		*/
		reset(value?: any, {onlySelf}?: {
		onlySelf?: boolean;
		}): void;
		/**
		* The aggregate value of the array, including any disabled controls.
		*
		* If you'd like to include all values regardless of disabled status, use this method.
		* Otherwise, the `value` property is the best way to get the value of the array.
		*/
		getRawValue(): any[];
		private _registerControl(control);
		}

583

src/model.js

		@@ -70,2 +70,10 @@ /**
		/**
		* @whatItDoes This is the base class for {@link FormControl}, {@link FormGroup}, and
		* {@link FormArray}.
		*
		* It provides some of the shared behavior that all controls and groups of controls have, like
		* running validators, calculating status, and resetting state. It also defines the properties
		* that are shared between all sub-classes, like `value`, `valid`, and `dirty`. It shouldn't be
		* instantiated directly.
		*
		* @stable
		@@ -83,2 +91,5 @@ */
		Object.defineProperty(AbstractControl.prototype, "value", {
		/**
		* The value of the control.
		*/
		get: function () { return this._value; },
		@@ -89,2 +100,14 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "status", {
		/**
		* The validation status of the control. There are four possible
		* validation statuses:
		*
		* * VALID: control has passed all validation checks
		* * INVALID: control has failed at least one validation check
		* * PENDING: control is in the midst of conducting a validation check
		* * DISABLED: control is exempt from validation checks
		*
		* These statuses are mutually exclusive, so a control cannot be
		* both valid AND invalid or invalid AND disabled.
		*/
		get: function () { return this._status; },
		@@ -95,2 +118,8 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "valid", {
		/**
		* A control is `valid` when its `status === VALID`.
		*
		* In order to have this status, the control must have passed all its
		* validation checks.
		*/
		get: function () { return this._status === VALID; },
		@@ -101,2 +130,8 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "invalid", {
		/**
		* A control is `invalid` when its `status === INVALID`.
		*
		* In order to have this status, the control must have failed
		* at least one of its validation checks.
		*/
		get: function () { return this._status === INVALID; },
		@@ -106,5 +141,40 @@ enumerable: true,
		});
		Object.defineProperty(AbstractControl.prototype, "pending", {
		/**
		* A control is `pending` when its `status === PENDING`.
		*
		* In order to have this status, the control must be in the
		* middle of conducting a validation check.
		*/
		get: function () { return this._status == PENDING; },
		enumerable: true,
		configurable: true
		});
		Object.defineProperty(AbstractControl.prototype, "disabled", {
		/**
		* A control is `disabled` when its `status === DISABLED`.
		*
		* Disabled controls are exempt from validation checks and
		* are not included in the aggregate value of their ancestor
		* controls.
		*/
		get: function () { return this._status === DISABLED; },
		enumerable: true,
		configurable: true
		});
		Object.defineProperty(AbstractControl.prototype, "enabled", {
		/**
		* A control is `enabled` as long as its `status !== DISABLED`.
		*
		* In other words, it has a status of `VALID`, `INVALID`, or
		* `PENDING`.
		*/
		get: function () { return this._status !== DISABLED; },
		enumerable: true,
		configurable: true
		});
		Object.defineProperty(AbstractControl.prototype, "errors", {
		/**
		* Returns the errors of this control.
		* Returns any errors generated by failing validation. If there
		* are no errors, it will return null.
		*/
		@@ -116,2 +186,9 @@ get: function () { return this._errors; },
		Object.defineProperty(AbstractControl.prototype, "pristine", {
		/**
		* A control is `pristine` if the user has not yet changed
		* the value in the UI.
		*
		* Note that programmatic changes to a control's value will
		* not mark it dirty.
		*/
		get: function () { return this._pristine; },
		@@ -122,2 +199,9 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "dirty", {
		/**
		* A control is `dirty` if the user has changed the value
		* in the UI.
		*
		* Note that programmatic changes to a control's value will
		* not mark it dirty.
		*/
		get: function () { return !this.pristine; },
		@@ -128,2 +212,6 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "touched", {
		/**
		* A control is marked `touched` once the user has triggered
		* a `blur` event on it.
		*/
		get: function () { return this._touched; },
		@@ -134,2 +222,6 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "untouched", {
		/**
		* A control is `untouched` if the user has not yet triggered
		* a `blur` event on it.
		*/
		get: function () { return !this._touched; },
		@@ -140,2 +232,6 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "valueChanges", {
		/**
		* Emits an event every time the value of the control changes, in
		* the UI or programmatically.
		*/
		get: function () { return this._valueChanges; },
		@@ -146,2 +242,6 @@ enumerable: true,
		Object.defineProperty(AbstractControl.prototype, "statusChanges", {
		/**
		* Emits an event every time the validation status of the control
		* is re-calculated.
		*/
		get: function () { return this._statusChanges; },
		@@ -151,25 +251,30 @@ enumerable: true,
		});
		Object.defineProperty(AbstractControl.prototype, "pending", {
		get: function () { return this._status == PENDING; },
		enumerable: true,
		configurable: true
		});
		Object.defineProperty(AbstractControl.prototype, "disabled", {
		get: function () { return this._status === DISABLED; },
		enumerable: true,
		configurable: true
		});
		Object.defineProperty(AbstractControl.prototype, "enabled", {
		get: function () { return this._status !== DISABLED; },
		enumerable: true,
		configurable: true
		});
		/**
		* Sets the synchronous validators that are active on this control. Calling
		* this will overwrite any existing sync validators.
		*/
		AbstractControl.prototype.setValidators = function (newValidator) {
		this.validator = coerceToValidator(newValidator);
		};
		/**
		* Sets the async validators that are active on this control. Calling this
		* will overwrite any existing async validators.
		*/
		AbstractControl.prototype.setAsyncValidators = function (newValidator) {
		this.asyncValidator = coerceToAsyncValidator(newValidator);
		};
		/**
		* Empties out the sync validator list.
		*/
		AbstractControl.prototype.clearValidators = function () { this.validator = null; };
		/**
		* Empties out the async validator list.
		*/
		AbstractControl.prototype.clearAsyncValidators = function () { this.asyncValidator = null; };
		AbstractControl.prototype.setValidators = function (newValidator) {
		this.validator = coerceToValidator(newValidator);
		};
		AbstractControl.prototype.clearValidators = function () { this.validator = null; };
		/**
		* Marks the control as `touched`.
		*
		* This will also mark all direct ancestors as `touched` to maintain
		* the model.
		*/
		AbstractControl.prototype.markAsTouched = function (_a) {
		@@ -183,2 +288,23 @@ var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		};
		/**
		* Marks the control as `untouched`.
		*
		* If the control has any children, it will also mark all children as `untouched`
		* to maintain the model, and re-calculate the `touched` status of all parent
		* controls.
		*/
		AbstractControl.prototype.markAsUntouched = function (_a) {
		var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		this._touched = false;
		this._forEachChild(function (control) { control.markAsUntouched({ onlySelf: true }); });
		if (isPresent(this._parent) && !onlySelf) {
		this._parent._updateTouched({ onlySelf: onlySelf });
		}
		};
		/**
		* Marks the control as `dirty`.
		*
		* This will also mark all direct ancestors as `dirty` to maintain
		* the model.
		*/
		AbstractControl.prototype.markAsDirty = function (_a) {
		@@ -192,2 +318,9 @@ var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		};
		/**
		* Marks the control as `pristine`.
		*
		* If the control has any children, it will also mark all children as `pristine`
		* to maintain the model, and re-calculate the `pristine` status of all parent
		* controls.
		*/
		AbstractControl.prototype.markAsPristine = function (_a) {
		@@ -201,10 +334,5 @@ var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		};
		AbstractControl.prototype.markAsUntouched = function (_a) {
		var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		this._touched = false;
		this._forEachChild(function (control) { control.markAsUntouched({ onlySelf: true }); });
		if (isPresent(this._parent) && !onlySelf) {
		this._parent._updateTouched({ onlySelf: onlySelf });
		}
		};
		/**
		* Marks the control as `pending`.
		*/
		AbstractControl.prototype.markAsPending = function (_a) {
		@@ -218,2 +346,8 @@ var onlySelf = (_a === void 0 ? {} : _a).onlySelf;
		};
		/**
		* Disables the control. This means the control will be exempt from validation checks and
		* excluded from the aggregate value of any parent. Its status is `DISABLED`.
		*
		* If the control has children, all children will be disabled to maintain the model.
		*/
		AbstractControl.prototype.disable = function (_a) {
		@@ -233,2 +367,9 @@ var _b = _a === void 0 ? {} : _a, onlySelf = _b.onlySelf, emitEvent = _b.emitEvent;
		};
		/**
		* Enables the control. This means the control will be included in validation checks and
		* the aggregate value of its parent. Its status is re-calculated based on its value and
		* its validators.
		*
		* If the control has children, all children will be enabled.
		*/
		AbstractControl.prototype.enable = function (_a) {
		@@ -250,2 +391,7 @@ var _b = _a === void 0 ? {} : _a, onlySelf = _b.onlySelf, emitEvent = _b.emitEvent;
		AbstractControl.prototype.setParent = function (parent) { this._parent = parent; };
		/**
		* Re-calculates the value and validation status of the control.
		*
		* By default, it will also update the value and validity of its ancestors.
		*/
		AbstractControl.prototype.updateValueAndValidity = function (_a) {
		@@ -299,10 +445,10 @@ var _b = _a === void 0 ? {} : _a, onlySelf = _b.onlySelf, emitEvent = _b.emitEvent;
		*
		* This is used when validations are run not automatically, but manually by the user.
		* This is used when validations are run manually by the user, rather than automatically.
		*
		* Calling `setErrors` will also update the validity of the parent control.
		*
		* ## Usage
		* ### Example
		*
		* ```
		* var login = new FormControl("someLogin");
		* const login = new FormControl("someLogin");
		* login.setErrors({
		@@ -315,3 +461,3 @@ * "notUnique": true
		*
		* login.updateValue("someOtherLogin");
		* login.setValue("someOtherLogin");
		*
		@@ -327,3 +473,22 @@ * expect(login.valid).toEqual(true);
		};
		/**
		* Retrieves a child control given the control's name or path.
		*
		* Paths can be passed in as an array or a string delimited by a dot.
		*
		* To get a control nested within a `person` sub-group:
		*
		* * `this.form.get('person.name');`
		*
		* -OR-
		*
		* * `this.form.get(['person', 'name']);`
		*/
		AbstractControl.prototype.get = function (path) { return _find(this, path, '.'); };
		/**
		* Returns true if the control with the given path has the error specified. Otherwise
		* returns null or undefined.
		*
		* If no path is given, it checks for the error on the present control.
		*/
		AbstractControl.prototype.getError = function (errorCode, path) {
		@@ -339,2 +504,8 @@ if (path === void 0) { path = null; }
		};
		/**
		* Returns true if the control with the given path has the error specified. Otherwise
		* returns false.
		*
		* If no path is given, it checks for the error on the present control.
		*/
		AbstractControl.prototype.hasError = function (errorCode, path) {
		@@ -345,2 +516,5 @@ if (path === void 0) { path = null; }
		Object.defineProperty(AbstractControl.prototype, "root", {
		/**
		* Retrieves the top-level ancestor of this control.
		*/
		get: function () {
		@@ -422,17 +596,40 @@ var x = this;
		/**
		* Defines a part of a form that cannot be divided into other controls. `FormControl`s have values
		* and
		* validation state, which is determined by an optional validation function.
		* @whatItDoes Tracks the value and validation status of an individual form control.
		*
		* `FormControl` is one of the three fundamental building blocks used to define forms in Angular,
		* along
		* with {@link FormGroup} and {@link FormArray}.
		* It is one of the three fundamental building blocks of Angular forms, along with
		* {@link FormGroup} and {@link FormArray}.
		*
		* ## Usage
		* @howToUse
		*
		* By default, a `FormControl` is created for every `<input>` or other form component.
		* With {@link FormControlDirective} or {@link FormGroupDirective} an existing {@link FormControl}
		* can be bound to a DOM element instead. This `FormControl` can be configured with a custom
		* validation function.
		* When instantiating a {@link FormControl}, you can pass in an initial value as the
		* first argument. Example:
		*
		* ```ts
		* const ctrl = new FormControl('some value');
		* console.log(ctrl.value); // 'some value'
		*```
		*
		* You can also initialize the control with a form state object on instantiation,
		* which includes both the value and whether or not the control is disabled.
		*
		* ```ts
		* const ctrl = new FormControl({value: 'n/a', disabled: true});
		* console.log(ctrl.value); // 'n/a'
		* console.log(ctrl.status); // 'DISABLED'
		* ```
		*
		* To include a sync validator (or an array of sync validators) with the control,
		* pass it in as the second argument. Async validators are also supported, but
		* have to be passed in separately as the third arg.
		*
		* ```ts
		* const ctrl = new FormControl('', Validators.required);
		* console.log(ctrl.value); // ''
		* console.log(ctrl.status); // 'INVALID'
		* ```
		*
		* See its superclass, {@link AbstractControl}, for more properties and methods.
		*
		* * npm package: `@angular/forms`
		*
		* @stable
		@@ -457,6 +654,8 @@ */
		* If `onlySelf` is `true`, this change will only affect the validation of this `FormControl`
		* and not its parent component. If `emitEvent` is `true`, this change will cause a
		* `valueChanges` event on the `FormControl` to be emitted. Both of these options default to
		* `false`.
		* and not its parent component. This defaults to false.
		*
		* If `emitEvent` is `true`, this
		* change will cause a `valueChanges` event on the `FormControl` to be emitted. This defaults
		* to true (as it falls through to `updateValueAndValidity`).
		*
		* If `emitModelToViewChange` is `true`, the view will be notified about the new value
		@@ -481,4 +680,7 @@ * via an `onChange` event. This is the default behavior if `emitModelToViewChange` is not
		/**
		* This function is functionally the same as updateValue() at this level. It exists for
		* symmetry with patchValue() on FormGroups and FormArrays, where it does behave differently.
		* Patches the value of a control.
		*
		* This function is functionally the same as {@link FormControl.setValue} at this level.
		* It exists for symmetry with {@link FormGroup.patchValue} on `FormGroups` and `FormArrays`,
		* where it does behave differently.
		*/
		@@ -489,2 +691,30 @@ FormControl.prototype.patchValue = function (value, options) {
		};
		/**
		* Resets the form control. This means by default:
		*
		* * it is marked as `pristine`
		* * it is marked as `untouched`
		* * value is set to null
		*
		* You can also reset to a specific form state by passing through a standalone
		* value or a form state object that contains both a value and a disabled state
		* (these are the only two properties that cannot be calculated).
		*
		* Ex:
		*
		* ```ts
		* this.control.reset('Nancy');
		*
		* console.log(this.control.value); // 'Nancy'
		* ```
		*
		* OR
		*
		* ```
		* this.control.reset({value: 'Nancy', disabled: true});
		*
		* console.log(this.control.value); // 'Nancy'
		* console.log(this.control.status); // 'DISABLED'
		* ```
		*/
		FormControl.prototype.reset = function (formState, _a) {
		@@ -543,14 +773,51 @@ if (formState === void 0) { formState = null; }
		/**
		* Defines a part of a form, of fixed length, that can contain other controls.
		* @whatItDoes Tracks the value and validity state of a group of {@link FormControl}
		* instances.
		*
		* A `FormGroup` aggregates the values of each {@link FormControl} in the group.
		* The status of a `FormGroup` depends on the status of its children.
		* If one of the controls in a group is invalid, the entire group is invalid.
		* Similarly, if a control changes its value, the entire group changes as well.
		* A `FormGroup` aggregates the values of each child {@link FormControl} into one object,
		* with each control name as the key. It calculates its status by reducing the statuses
		* of its children. For example, if one of the controls in a group is invalid, the entire
		* group becomes invalid.
		*
		* `FormGroup` is one of the three fundamental building blocks used to define forms in Angular,
		* along with {@link FormControl} and {@link FormArray}. {@link FormArray} can also contain other
		* controls, but is of variable length.
		* along with {@link FormControl} and {@link FormArray}.
		*
		* @howToUse
		*
		* When instantiating a {@link FormGroup}, pass in a collection of child controls as the first
		* argument. The key for each child will be the name under which it is registered.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl('Nancy', Validators.minLength(2)),
		* last: new FormControl('Drew'),
		* });
		*
		* console.log(form.value); // {first: 'Nancy', last; 'Drew'}
		* console.log(form.status); // 'VALID'
		* ```
		*
		* You can also include group-level validators as the second arg, or group-level async
		* validators as the third arg. These come in handy when you want to perform validation
		* that considers the value of more than one child control.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* password: new FormControl('', Validators.minLength(2)),
		* passwordConfirm: new FormControl('', Validators.minLength(2)),
		* }, passwordMatchValidator);
		*
		*
		* function passwordMatchValidator(g: FormGroup) {
		* return g.get('password').value === g.get('passwordConfirm').value
		* ? null : {'mismatch': true};
		* }
		* ```
		*
		* * npm package: `@angular/forms`
		*
		* @stable
		@@ -570,3 +837,6 @@ */
		/**
		* Register a control with the group's list of controls.
		* Registers a control with the group's list of controls.
		*
		* This method does not update value or validity of the control, so for
		* most cases you'll want to use {@link FormGroup.addControl} instead.
		*/
		@@ -612,3 +882,6 @@ FormGroup.prototype.registerControl = function (name, control) {
		/**
		* Check whether there is a control with the given name in the group.
		* Check whether there is an enabled control with the given name in the group.
		*
		* It will return false for disabled controls. If you'd like to check for
		* existence in the group only, use {@link AbstractControl.get} instead.
		*/
		@@ -618,2 +891,24 @@ FormGroup.prototype.contains = function (controlName) {
		};
		/**
		* Sets the value of the {@link FormGroup}. It accepts an object that matches
		* the structure of the group, with control names as keys.
		*
		* This method performs strict checks, so it will throw an error if you try
		* to set the value of a control that doesn't exist or if you exclude the
		* value of a control.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl(),
		* last: new FormControl()
		* });
		* console.log(form.value); // {first: null, last: null}
		*
		* form.setValue({first: 'Nancy', last: 'Drew'});
		* console.log(form.value); // {first: 'Nancy', last: 'Drew'}
		*
		* ```
		*/
		FormGroup.prototype.setValue = function (value, _a) {
		@@ -629,2 +924,23 @@ var _this = this;
		};
		/**
		* Patches the value of the {@link FormGroup}. It accepts an object with control
		* names as keys, and will do its best to match the values to the correct controls
		* in the group.
		*
		* It accepts both super-sets and sub-sets of the group without throwing an error.
		*
		* ### Example
		*
		* ```
		* const form = new FormGroup({
		* first: new FormControl(),
		* last: new FormControl()
		* });
		* console.log(form.value); // {first: null, last: null}
		*
		* form.patchValue({first: 'Nancy'});
		* console.log(form.value); // {first: 'Nancy', last: null}
		*
		* ```
		*/
		FormGroup.prototype.patchValue = function (value, _a) {
		@@ -640,2 +956,34 @@ var _this = this;
		};
		/**
		* Resets the {@link FormGroup}. This means by default:
		*
		* * The group and all descendants are marked `pristine`
		* * The group and all descendants are marked `untouched`
		* * The value of all descendants will be null or null maps
		*
		* You can also reset to a specific form state by passing in a map of states
		* that matches the structure of your form, with control names as keys. The state
		* can be a standalone value or a form state object with both a value and a disabled
		* status.
		*
		* ### Example
		*
		* ```ts
		* this.form.reset({first: 'name', last; 'last name'});
		*
		* console.log(this.form.value); // {first: 'name', last: 'last name'}
		* ```
		*
		* - OR -
		*
		* ```
		* this.form.reset({
		* first: {value: 'name', disabled: true},
		* last: 'last'
		* });
		*
		* console.log(this.form.value); // {first: 'name', last: 'last name'}
		* console.log(this.form.get('first').status); // 'DISABLED'
		* ```
		*/
		FormGroup.prototype.reset = function (value, _a) {
		@@ -651,2 +999,8 @@ if (value === void 0) { value = {}; }
		};
		/**
		* The aggregate value of the {@link FormGroup}, including any disabled controls.
		*
		* If you'd like to include all values regardless of disabled status, use this method.
		* Otherwise, the `value` property is the best way to get the value of the group.
		*/
		FormGroup.prototype.getRawValue = function () {
		@@ -727,15 +1081,35 @@ return this._reduceChildren({}, function (acc, control, name) {
		/**
		* Defines a part of a form, of variable length, that can contain other controls.
		* @whatItDoes Tracks the value and validity state of an array of {@link FormControl}
		* instances.
		*
		* A `FormArray` aggregates the values of each {@link FormControl} in the group.
		* The status of a `FormArray` depends on the status of its children.
		* If one of the controls in a group is invalid, the entire array is invalid.
		* Similarly, if a control changes its value, the entire array changes as well.
		* A `FormArray` aggregates the values of each child {@link FormControl} into an array.
		* It calculates its status by reducing the statuses of its children. For example, if one of
		* the controls in a `FormArray` is invalid, the entire array becomes invalid.
		*
		* `FormArray` is one of the three fundamental building blocks used to define forms in Angular,
		* along with {@link FormControl} and {@link FormGroup}. {@link FormGroup} can also contain
		* other controls, but is of fixed length.
		* along with {@link FormControl} and {@link FormGroup}.
		*
		* ## Adding or removing controls
		* @howToUse
		*
		* When instantiating a {@link FormArray}, pass in an array of child controls as the first
		* argument.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl('Nancy', Validators.minLength(2)),
		* new FormControl('Drew'),
		* ]);
		*
		* console.log(arr.value); // ['Nancy', 'Drew']
		* console.log(arr.status); // 'VALID'
		* ```
		*
		* You can also include array-level validators as the second arg, or array-level async
		* validators as the third arg. These come in handy when you want to perform validation
		* that considers the value of more than one child control.
		*
		* ### Adding or removing controls
		*
		* To change the controls in the array, use the `push`, `insert`, or `removeAt` methods
		@@ -747,2 +1121,3 @@ * in `FormArray` itself. These methods ensure the controls are properly tracked in the
		*
		* * npm package: `@angular/forms`
		*
		@@ -816,2 +1191,23 @@ * @stable
		});
		/**
		* Sets the value of the {@link FormArray}. It accepts an array that matches
		* the structure of the control.
		*
		* This method performs strict checks, so it will throw an error if you try
		* to set the value of a control that doesn't exist or if you exclude the
		* value of a control.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl(),
		* new FormControl()
		* ]);
		* console.log(arr.value); // [null, null]
		*
		* arr.setValue(['Nancy', 'Drew']);
		* console.log(arr.value); // ['Nancy', 'Drew']
		* ```
		*/
		FormArray.prototype.setValue = function (value, _a) {
		@@ -827,2 +1223,22 @@ var _this = this;
		};
		/**
		* Patches the value of the {@link FormArray}. It accepts an array that matches the
		* structure of the control, and will do its best to match the values to the correct
		* controls in the group.
		*
		* It accepts both super-sets and sub-sets of the array without throwing an error.
		*
		* ### Example
		*
		* ```
		* const arr = new FormArray([
		* new FormControl(),
		* new FormControl()
		* ]);
		* console.log(arr.value); // [null, null]
		*
		* arr.patchValue(['Nancy']);
		* console.log(arr.value); // ['Nancy', null]
		* ```
		*/
		FormArray.prototype.patchValue = function (value, _a) {
		@@ -838,2 +1254,33 @@ var _this = this;
		};
		/**
		* Resets the {@link FormArray}. This means by default:
		*
		* * The array and all descendants are marked `pristine`
		* * The array and all descendants are marked `untouched`
		* * The value of all descendants will be null or null maps
		*
		* You can also reset to a specific form state by passing in an array of states
		* that matches the structure of the control. The state can be a standalone value
		* or a form state object with both a value and a disabled status.
		*
		* ### Example
		*
		* ```ts
		* this.arr.reset(['name', 'last name']);
		*
		* console.log(this.arr.value); // ['name', 'last name']
		* ```
		*
		* - OR -
		*
		* ```
		* this.arr.reset([
		* {value: 'name', disabled: true},
		* 'last'
		* ]);
		*
		* console.log(this.arr.value); // ['name', 'last name']
		* console.log(this.arr.get(0).status); // 'DISABLED'
		* ```
		*/
		FormArray.prototype.reset = function (value, _a) {
		@@ -849,2 +1296,8 @@ if (value === void 0) { value = []; }
		};
		/**
		* The aggregate value of the array, including any disabled controls.
		*
		* If you'd like to include all values regardless of disabled status, use this method.
		* Otherwise, the `value` property is the best way to get the value of the array.
		*/
		FormArray.prototype.getRawValue = function () { return this.controls.map(function (control) { return control.value; }); };
		@@ -851,0 +1304,0 @@ /** @internal */

bundles/forms.umd.js

Sorry, the diff of this file is too big to display

bundles/forms.umd.min.js

Sorry, the diff of this file is too big to display

src/form_builder.js.map

Sorry, the diff of this file is not supported yet

src/model.js.map

Sorry, the diff of this file is not supported yet

@angular/forms - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics