@angular/forms
Version:
Angular - directives and services for creating forms
203 lines • 21.4 kB
JavaScript
/**
* @license
* Copyright Google LLC All Rights Reserved.
*
* Use of this source code is governed by an MIT-style license that can be
* found in the LICENSE file at https://angular.io/license
*/
import { Directive, forwardRef, Host, Inject, Input, Optional, Self, SkipSelf } from '@angular/core';
import { NG_ASYNC_VALIDATORS, NG_VALIDATORS } from '../../validators';
import { AbstractFormGroupDirective } from '../abstract_form_group_directive';
import { ControlContainer } from '../control_container';
import { ReactiveErrors } from '../reactive_errors';
import { composeAsyncValidators, composeValidators, controlPath } from '../shared';
import { FormGroupDirective } from './form_group_directive';
export const formGroupNameProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => FormGroupName)
};
/**
* @description
*
* Syncs a nested `FormGroup` to a DOM element.
*
* This directive can only be used with a parent `FormGroupDirective`.
*
* It accepts the string name of the nested `FormGroup` to link, and
* looks for a `FormGroup` registered with that name in the parent
* `FormGroup` instance you passed into `FormGroupDirective`.
*
* Use nested form groups to validate a sub-group of a
* form separately from the rest or to group the values of certain
* controls into their own nested object.
*
* @see [Reactive Forms Guide](guide/reactive-forms)
*
* @usageNotes
*
* ### Access the group by name
*
* The following example uses the {@link AbstractControl#get get} method to access the
* associated `FormGroup`
*
* ```ts
* this.form.get('name');
* ```
*
* ### Access individual controls in the group
*
* The following example uses the {@link AbstractControl#get get} method to access
* individual controls within the group using dot syntax.
*
* ```ts
* this.form.get('name.first');
* ```
*
* ### Register a nested `FormGroup`.
*
* The following example registers a nested *name* `FormGroup` within an existing `FormGroup`,
* and provides methods to retrieve the nested `FormGroup` and individual controls.
*
* {@example forms/ts/nestedFormGroup/nested_form_group_example.ts region='Component'}
*
* @ngModule ReactiveFormsModule
* @publicApi
*/
export class FormGroupName extends AbstractFormGroupDirective {
constructor(parent, validators, asyncValidators) {
super();
this._parent = parent;
this._validators = validators;
this._asyncValidators = asyncValidators;
}
/** @internal */
_checkParentType() {
if (_hasInvalidParent(this._parent)) {
ReactiveErrors.groupParentException();
}
}
}
FormGroupName.decorators = [
{ type: Directive, args: [{ selector: '[formGroupName]', providers: [formGroupNameProvider] },] }
];
FormGroupName.ctorParameters = () => [
{ type: ControlContainer, decorators: [{ type: Optional }, { type: Host }, { type: SkipSelf }] },
{ type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_VALIDATORS,] }] },
{ type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_ASYNC_VALIDATORS,] }] }
];
FormGroupName.propDecorators = {
name: [{ type: Input, args: ['formGroupName',] }]
};
export const formArrayNameProvider = {
provide: ControlContainer,
useExisting: forwardRef(() => FormArrayName)
};
/**
* @description
*
* Syncs a nested `FormArray` to a DOM element.
*
* This directive is designed to be used with a parent `FormGroupDirective` (selector:
* `[formGroup]`).
*
* It accepts the string name of the nested `FormArray` you want to link, and
* will look for a `FormArray` registered with that name in the parent
* `FormGroup` instance you passed into `FormGroupDirective`.
*
* @see [Reactive Forms Guide](guide/reactive-forms)
* @see `AbstractControl`
*
* @usageNotes
*
* ### Example
*
* {@example forms/ts/nestedFormArray/nested_form_array_example.ts region='Component'}
*
* @ngModule ReactiveFormsModule
* @publicApi
*/
export class FormArrayName extends ControlContainer {
constructor(parent, validators, asyncValidators) {
super();
this._parent = parent;
this._validators = validators;
this._asyncValidators = asyncValidators;
}
/**
* @description
* A lifecycle method called when the directive's inputs are initialized. For internal use only.
*
* @throws If the directive does not have a valid parent.
*/
ngOnInit() {
this._checkParentType();
this.formDirective.addFormArray(this);
}
/**
* @description
* A lifecycle method called before the directive's instance is destroyed. For internal use only.
*/
ngOnDestroy() {
if (this.formDirective) {
this.formDirective.removeFormArray(this);
}
}
/**
* @description
* The `FormArray` bound to this directive.
*/
get control() {
return this.formDirective.getFormArray(this);
}
/**
* @description
* The top-level directive for this group if present, otherwise null.
*/
get formDirective() {
return this._parent ? this._parent.formDirective : null;
}
/**
* @description
* Returns an array that represents the path from the top-level form to this control.
* Each index is the string name of the control on that level.
*/
get path() {
return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);
}
/**
* @description
* Synchronous validator function composed of all the synchronous validators registered with this
* directive.
*/
get validator() {
return composeValidators(this._validators);
}
/**
* @description
* Async validator function composed of all the async validators registered with this directive.
*/
get asyncValidator() {
return composeAsyncValidators(this._asyncValidators);
}
_checkParentType() {
if (_hasInvalidParent(this._parent)) {
ReactiveErrors.arrayParentException();
}
}
}
FormArrayName.decorators = [
{ type: Directive, args: [{ selector: '[formArrayName]', providers: [formArrayNameProvider] },] }
];
FormArrayName.ctorParameters = () => [
{ type: ControlContainer, decorators: [{ type: Optional }, { type: Host }, { type: SkipSelf }] },
{ type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_VALIDATORS,] }] },
{ type: Array, decorators: [{ type: Optional }, { type: Self }, { type: Inject, args: [NG_ASYNC_VALIDATORS,] }] }
];
FormArrayName.propDecorators = {
name: [{ type: Input, args: ['formArrayName',] }]
};
function _hasInvalidParent(parent) {
return !(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) &&
!(parent instanceof FormArrayName);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form_group_name.js","sourceRoot":"","sources":["../../../../../../../../packages/forms/src/directives/reactive_directives/form_group_name.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright Google LLC All Rights Reserved.\n *\n * Use of this source code is governed by an MIT-style license that can be\n * found in the LICENSE file at https://angular.io/license\n */\n\nimport {Directive, forwardRef, Host, Inject, Input, OnDestroy, OnInit, Optional, Self, SkipSelf} from '@angular/core';\n\nimport {FormArray} from '../../model';\nimport {NG_ASYNC_VALIDATORS, NG_VALIDATORS} from '../../validators';\nimport {AbstractFormGroupDirective} from '../abstract_form_group_directive';\nimport {ControlContainer} from '../control_container';\nimport {ReactiveErrors} from '../reactive_errors';\nimport {composeAsyncValidators, composeValidators, controlPath} from '../shared';\nimport {AsyncValidatorFn, ValidatorFn} from '../validators';\n\nimport {FormGroupDirective} from './form_group_directive';\n\nexport const formGroupNameProvider: any = {\n  provide: ControlContainer,\n  useExisting: forwardRef(() => FormGroupName)\n};\n\n/**\n * @description\n *\n * Syncs a nested `FormGroup` to a DOM element.\n *\n * This directive can only be used with a parent `FormGroupDirective`.\n *\n * It accepts the string name of the nested `FormGroup` to link, and\n * looks for a `FormGroup` registered with that name in the parent\n * `FormGroup` instance you passed into `FormGroupDirective`.\n *\n * Use nested form groups to validate a sub-group of a\n * form separately from the rest or to group the values of certain\n * controls into their own nested object.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n *\n * @usageNotes\n *\n * ### Access the group by name\n *\n * The following example uses the {@link AbstractControl#get get} method to access the\n * associated `FormGroup`\n *\n * ```ts\n *   this.form.get('name');\n * ```\n *\n * ### Access individual controls in the group\n *\n * The following example uses the {@link AbstractControl#get get} method to access\n * individual controls within the group using dot syntax.\n *\n * ```ts\n *   this.form.get('name.first');\n * ```\n *\n * ### Register a nested `FormGroup`.\n *\n * The following example registers a nested *name* `FormGroup` within an existing `FormGroup`,\n * and provides methods to retrieve the nested `FormGroup` and individual controls.\n *\n * {@example forms/ts/nestedFormGroup/nested_form_group_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\n@Directive({selector: '[formGroupName]', providers: [formGroupNameProvider]})\nexport class FormGroupName extends AbstractFormGroupDirective implements OnInit, OnDestroy {\n  /**\n   * @description\n   * Tracks the name of the `FormGroup` bound to the directive. The name corresponds\n   * to a key in the parent `FormGroup` or `FormArray`.\n   * Accepts a name as a string or a number.\n   * The name in the form of a string is useful for individual forms,\n   * while the numerical form allows for form groups to be bound\n   * to indices when iterating over groups in a `FormArray`.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input('formGroupName') name!: string|number|null;\n\n  constructor(\n      @Optional() @Host() @SkipSelf() parent: ControlContainer,\n      @Optional() @Self() @Inject(NG_VALIDATORS) validators: any[],\n      @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) asyncValidators: any[]) {\n    super();\n    this._parent = parent;\n    this._validators = validators;\n    this._asyncValidators = asyncValidators;\n  }\n\n  /** @internal */\n  _checkParentType(): void {\n    if (_hasInvalidParent(this._parent)) {\n      ReactiveErrors.groupParentException();\n    }\n  }\n}\n\nexport const formArrayNameProvider: any = {\n  provide: ControlContainer,\n  useExisting: forwardRef(() => FormArrayName)\n};\n\n/**\n * @description\n *\n * Syncs a nested `FormArray` to a DOM element.\n *\n * This directive is designed to be used with a parent `FormGroupDirective` (selector:\n * `[formGroup]`).\n *\n * It accepts the string name of the nested `FormArray` you want to link, and\n * will look for a `FormArray` registered with that name in the parent\n * `FormGroup` instance you passed into `FormGroupDirective`.\n *\n * @see [Reactive Forms Guide](guide/reactive-forms)\n * @see `AbstractControl`\n *\n * @usageNotes\n *\n * ### Example\n *\n * {@example forms/ts/nestedFormArray/nested_form_array_example.ts region='Component'}\n *\n * @ngModule ReactiveFormsModule\n * @publicApi\n */\n@Directive({selector: '[formArrayName]', providers: [formArrayNameProvider]})\nexport class FormArrayName extends ControlContainer implements OnInit, OnDestroy {\n  /** @internal */\n  _parent: ControlContainer;\n\n  /** @internal */\n  _validators: any[];\n\n  /** @internal */\n  _asyncValidators: any[];\n\n  /**\n   * @description\n   * Tracks the name of the `FormArray` bound to the directive. The name corresponds\n   * to a key in the parent `FormGroup` or `FormArray`.\n   * Accepts a name as a string or a number.\n   * The name in the form of a string is useful for individual forms,\n   * while the numerical form allows for form arrays to be bound\n   * to indices when iterating over arrays in a `FormArray`.\n   */\n  // TODO(issue/24571): remove '!'.\n  @Input('formArrayName') name!: string|number|null;\n\n  constructor(\n      @Optional() @Host() @SkipSelf() parent: ControlContainer,\n      @Optional() @Self() @Inject(NG_VALIDATORS) validators: any[],\n      @Optional() @Self() @Inject(NG_ASYNC_VALIDATORS) asyncValidators: any[]) {\n    super();\n    this._parent = parent;\n    this._validators = validators;\n    this._asyncValidators = asyncValidators;\n  }\n\n  /**\n   * @description\n   * A lifecycle method called when the directive's inputs are initialized. For internal use only.\n   *\n   * @throws If the directive does not have a valid parent.\n   */\n  ngOnInit(): void {\n    this._checkParentType();\n    this.formDirective!.addFormArray(this);\n  }\n\n  /**\n   * @description\n   * A lifecycle method called before the directive's instance is destroyed. For internal use only.\n   */\n  ngOnDestroy(): void {\n    if (this.formDirective) {\n      this.formDirective.removeFormArray(this);\n    }\n  }\n\n  /**\n   * @description\n   * The `FormArray` bound to this directive.\n   */\n  get control(): FormArray {\n    return this.formDirective!.getFormArray(this);\n  }\n\n  /**\n   * @description\n   * The top-level directive for this group if present, otherwise null.\n   */\n  get formDirective(): FormGroupDirective|null {\n    return this._parent ? <FormGroupDirective>this._parent.formDirective : null;\n  }\n\n  /**\n   * @description\n   * Returns an array that represents the path from the top-level form to this control.\n   * Each index is the string name of the control on that level.\n   */\n  get path(): string[] {\n    return controlPath(this.name == null ? this.name : this.name.toString(), this._parent);\n  }\n\n  /**\n   * @description\n   * Synchronous validator function composed of all the synchronous validators registered with this\n   * directive.\n   */\n  get validator(): ValidatorFn|null {\n    return composeValidators(this._validators);\n  }\n\n  /**\n   * @description\n   * Async validator function composed of all the async validators registered with this directive.\n   */\n  get asyncValidator(): AsyncValidatorFn|null {\n    return composeAsyncValidators(this._asyncValidators);\n  }\n\n  private _checkParentType(): void {\n    if (_hasInvalidParent(this._parent)) {\n      ReactiveErrors.arrayParentException();\n    }\n  }\n}\n\nfunction _hasInvalidParent(parent: ControlContainer): boolean {\n  return !(parent instanceof FormGroupName) && !(parent instanceof FormGroupDirective) &&\n      !(parent instanceof FormArrayName);\n}\n"]}