@ng-stack/forms
Version:
> provides wrapped Angular's Reactive Forms to write its more strongly typed.
327 lines (319 loc) • 32.6 kB
JavaScript
import { UntypedFormGroup as NativeFormGroup } from '@angular/forms';
export class FormGroup extends NativeFormGroup {
/**
* Creates a new `FormGroup` instance.
*
* @param controls A collection of child controls. The key for each child is the name
* under which it is registered.
*
* @param validatorOrOpts A synchronous validator function, or an array of
* such functions, or an `AbstractControlOptions` object that contains validation functions
* and a validation trigger.
*
* @param asyncValidator A single async validator or array of async validator functions
*
* @todo Chechout how to respect optional and require properties modifyers for the controls.
*/
constructor(controls, validatorOrOpts, asyncValidator) {
super(controls, validatorOrOpts, asyncValidator);
this.controls = controls;
}
/**
* Registers a control with the group's list of controls.
*
* This method does not update the value or validity of the control.
* Use [addControl](https://angular.io/api/forms/FormGroup#addControl) instead.
*
* @param name The control name to register in the collection
* @param control Provides the control for the given name
*/
registerControl(name, control) {
return super.registerControl(name, control);
}
/**
* Add a control to this group.
*
* This method also updates the value and validity of the control.
*
* @param name The control name to add to the collection
* @param control Provides the control for the given name
*/
addControl(name, control) {
return super.addControl(name, control);
}
/**
* Remove a control from this group.
*
* @param name The control name to remove from the collection
*/
removeControl(name) {
return super.removeControl(name);
}
/**
* Replace an existing control.
*
* @param name The control name to replace in the collection
* @param control Provides the control for the given name
*/
setControl(name, control) {
return super.setControl(name, control);
}
/**
* Check whether there is an enabled control with the given name in the group.
*
* Reports false for disabled controls. If you'd like to check for existence in the group
* only, use [get](https://angular.io/api/forms/AbstractControl#get) instead.
*
* @param name The control name to check for existence in the collection
*
* @returns false for disabled controls, true otherwise.
*/
contains(name) {
return super.contains(name);
}
/**
* Sets the value of the `FormGroup`. It accepts an object that matches
* the structure of the group, with control names as keys.
*
* ### Set the complete value for the form group
*
```ts
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'}
```
*
* @throws When strict checks fail, such as setting the value of a control
* that doesn't exist or if you excluding the value of a control.
*
* @param value The new value for the control that matches the structure of the group.
* @param options Configuration options that determine how the control propagates changes
* and emits events after the value changes.
* The configuration options are passed to the
* [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.
*
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
* false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control value is updated.
* When false, no events are emitted.
*/
setValue(value, options = {}) {
return super.setValue(value, options);
}
/**
* Patches the value of the `FormGroup`. It accepts an object with control
* names as keys, and does 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.
*
* ### Patch the value for a form group
*
```ts
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}
```
*
* @param value The object that matches the structure of the group.
* @param options Configuration options that determine how the control propagates changes and
* emits events after the value is patched.
* * `onlySelf`: When true, each change only affects this control and not its parent. Default is
* true.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control value is updated.
* When false, no events are emitted.
* The configuration options are passed to the
* [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.
*/
patchValue(value, options = {}) {
return super.patchValue(value, options);
}
/**
* Resets the `FormGroup`, marks all descendants are marked `pristine` and `untouched`, and
* the value of all descendants to null.
*
* You 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
* is a standalone value or a form state object with both a value and a disabled
* status.
*
* @param formState Resets the control with an initial value,
* or an object that defines the initial value and disabled state.
*
* @param options Configuration options that determine how the control propagates changes
* and emits events when the group is reset.
* * `onlySelf`: When true, each change only affects this control, and not its parent. Default is
* false.
* * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and
* `valueChanges`
* observables emit events with the latest status and value when the control is reset.
* When false, no events are emitted.
* The configuration options are passed to the
* [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.
*
*
* ### Reset the form group values
*
```ts
const form = new FormGroup({
first: new FormControl('first name'),
last: new FormControl('last name')
});
console.log(form.value); // {first: 'first name', last: 'last name'}
form.reset({ first: 'name', last: 'last name' });
console.log(form.value); // {first: 'name', last: 'last name'}
```
*
* ### Reset the form group values and disabled status
*
```ts
const form = new FormGroup({
first: new FormControl('first name'),
last: new FormControl('last name')
});
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 = {}, options = {}) {
return super.reset(value, options);
}
/**
* The aggregate value of the `FormGroup`, including any disabled controls.
*
* Retrieves all values regardless of disabled status.
* The `value` property is the best way to get the value of the group, because
* it excludes disabled controls in the `FormGroup`.
*/
getRawValue() {
return super.getRawValue();
}
/**
* Retrieves a child control given the control's name.
*
* ### Retrieve a nested control
*
* For example, to get a `name` control nested within a `person` sub-group:
```ts
this.form.get('person').get('name');
```
*/
get(controlName) {
return super.get(controlName);
}
/**
* Sets the synchronous validators that are active on this control. Calling
* this overwrites any existing sync validators.
*/
setValidators(newValidator) {
return super.setValidators(newValidator);
}
/**
* Sets the async validators that are active on this control. Calling this
* overwrites any existing async validators.
*/
setAsyncValidators(newValidator) {
return super.setAsyncValidators(newValidator);
}
/**
* Sets errors on a form control when running validations manually, rather than automatically.
*
* Calling `setErrors` also updates the validity of the parent control.
*
* ### Manually set the errors for a control
*
* ```ts
* const login = new FormControl('someLogin');
* login.setErrors({
* notUnique: true
* });
*
* expect(login.valid).toEqual(false);
* expect(login.errors).toEqual({ notUnique: true });
*
* login.setValue('someOtherLogin');
*
* expect(login.valid).toEqual(true);
* ```
*/
setErrors(errors, opts = {}) {
return super.setErrors(errors, opts);
}
/**
* Reports error data for the control with the given controlName.
*
* @param errorCode The code of the error to check
* @param controlName A control name that designates how to move from the current control
* to the control that should be queried for errors.
*
* For example, for the following `FormGroup`:
*
```ts
form = new FormGroup({
address: new FormGroup({ street: new FormControl() })
});
```
*
* The controlName to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in combination with `get()` method:
*
```ts
form.get('address').getError('someErrorCode', 'street');
```
*
* @returns error data for that particular error. If the control or error is not present,
* null is returned.
*/
getError(errorCode, controlName) {
return super.getError(errorCode, controlName);
}
/**
* Reports whether the control with the given controlName has the error specified.
*
* @param errorCode The code of the error to check
* @param controlName A control name that designates how to move from the current control
* to the control that should be queried for errors.
*
* For example, for the following `FormGroup`:
*
```ts
form = new FormGroup({
address: new FormGroup({ street: new FormControl() })
});
```
*
* The controlName to the 'street' control from the root form would be 'address' -> 'street'.
*
* It can be provided to this method in combination with `get()` method:
```ts
form.get('address').hasError('someErrorCode', 'street');
```
*
* If no controlName is given, this method checks for the error on the current control.
*
* @returns whether the given error is present in the control at the given controlName.
*
* If the control is not present, false is returned.
*/
hasError(errorCode, controlName) {
return super.hasError(errorCode, controlName);
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"form-group.js","sourceRoot":"","sources":["../../../../projects/forms/src/lib/form-group.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,IAAI,eAAe,EAAE,MAAM,gBAAgB,CAAC;AAgBrE,MAAM,OAAO,SAGX,SAAQ,eAAe;IAOvB;;;;;;;;;;;;;OAaG;IACH,YACkB,QAAkD,EAClE,eAIQ,EACR,cAA6D;QAE7D,KAAK,CAAC,QAAQ,EAAE,eAAe,EAAE,cAAc,CAAC,CAAC;QARjC,aAAQ,GAAR,QAAQ,CAA0C;IASpE,CAAC;IAED;;;;;;;;OAQG;IACM,eAAe,CAGtB,IAAO,EAAE,OAA8B;QACvC,OAAO,KAAK,CAAC,eAAe,CAAC,IAAI,EAAE,OAAO,CAA0B,CAAC;IACvE,CAAC;IAED;;;;;;;OAOG;IACM,UAAU,CAGjB,IAAO,EAAE,OAA8B;QACvC,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED;;;;OAIG;IACM,aAAa,CAA0B,IAAO;QACrD,OAAO,KAAK,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IACnC,CAAC;IAED;;;;;OAKG;IACM,UAAU,CAGjB,IAAO,EAAE,OAA8B;QACvC,OAAO,KAAK,CAAC,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;;OASG;IACM,QAAQ,CAA0B,IAAO;QAChD,OAAO,KAAK,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiCG;IACM,QAAQ,CACf,KAA2B,EAC3B,UAAuD,EAAE;QAEzD,OAAO,KAAK,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA+BG;IACM,UAAU,CACjB,KAAoC,EACpC,UAAuD,EAAE;QAEzD,OAAO,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAuDG;IACM,KAAK,CACZ,QAA8B,EAAS,EACvC,UAAuD,EAAE;QAEzD,OAAO,KAAK,CAAC,KAAK,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACM,WAAW;QAClB,OAAO,KAAK,CAAC,WAAW,EAA0B,CAAC;IACrD,CAAC;IAED;;;;;;;;;OASG;IACM,GAAG,CACV,WAAc;QAEd,OAAO,KAAK,CAAC,GAAG,CAAC,WAAW,CAAiC,CAAC;IAChE,CAAC;IAED;;;OAGG;IACM,aAAa,CAAC,YAAgD;QACrE,OAAO,KAAK,CAAC,aAAa,CAAC,YAAY,CAAC,CAAC;IAC3C,CAAC;IAED;;;OAGG;IACM,kBAAkB,CACzB,YAA0D;QAE1D,OAAO,KAAK,CAAC,kBAAkB,CAAC,YAAY,CAAC,CAAC;IAChD,CAAC;IAED;;;;;;;;;;;;;;;;;;;;OAoBG;IACM,SAAS,CAChB,MAA+B,EAC/B,OAAgC,EAAE;QAElC,OAAO,KAAK,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;IACvC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACM,QAAQ,CACf,SAAY,EACZ,WAAe;QAEf,OAAO,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAgB,CAAC;IAC/D,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACM,QAAQ,CACf,SAAY,EACZ,WAAe;QAEf,OAAO,KAAK,CAAC,QAAQ,CAAC,SAAS,EAAE,WAAW,CAAC,CAAC;IAChD,CAAC;CACF","sourcesContent":["import { UntypedFormGroup as NativeFormGroup } from '@angular/forms';\n\nimport { Observable } from 'rxjs';\n\nimport {\n  Status,\n  StringKeys,\n  ValidatorFn,\n  AsyncValidatorFn,\n  ValidatorsModel,\n  ValidationErrors,\n  AbstractControlOptions,\n  ControlType,\n  ExtractGroupValue,\n} from './types';\n\nexport class FormGroup<\n  T extends object = any,\n  V extends object = ValidatorsModel\n> extends NativeFormGroup {\n  override readonly value: ExtractGroupValue<T>;\n  override readonly valueChanges: Observable<ExtractGroupValue<T>>;\n  override readonly status: Status;\n  override readonly statusChanges: Observable<Status>;\n  override readonly errors: ValidationErrors<V> | null;\n\n  /**\n   * Creates a new `FormGroup` instance.\n   *\n   * @param controls A collection of child controls. The key for each child is the name\n   * under which it is registered.\n   *\n   * @param validatorOrOpts A synchronous validator function, or an array of\n   * such functions, or an `AbstractControlOptions` object that contains validation functions\n   * and a validation trigger.\n   *\n   * @param asyncValidator A single async validator or array of async validator functions\n   *\n   * @todo Chechout how to respect optional and require properties modifyers for the controls.\n   */\n  constructor(\n    public override controls: { [P in keyof T]: ControlType<T[P], V> },\n    validatorOrOpts?:\n      | ValidatorFn\n      | ValidatorFn[]\n      | AbstractControlOptions\n      | null,\n    asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[] | null\n  ) {\n    super(controls, validatorOrOpts, asyncValidator);\n  }\n\n  /**\n   * Registers a control with the group's list of controls.\n   *\n   * This method does not update the value or validity of the control.\n   * Use [addControl](https://angular.io/api/forms/FormGroup#addControl) instead.\n   *\n   * @param name The control name to register in the collection\n   * @param control Provides the control for the given name\n   */\n  override registerControl<\n    K extends StringKeys<T>,\n    CV extends object = ValidatorsModel\n  >(name: K, control: ControlType<T[K], CV>) {\n    return super.registerControl(name, control) as ControlType<T[K], CV>;\n  }\n\n  /**\n   * Add a control to this group.\n   *\n   * This method also updates the value and validity of the control.\n   *\n   * @param name The control name to add to the collection\n   * @param control Provides the control for the given name\n   */\n  override addControl<\n    K extends StringKeys<T>,\n    CV extends object = ValidatorsModel\n  >(name: K, control: ControlType<T[K], CV>) {\n    return super.addControl(name, control);\n  }\n\n  /**\n   * Remove a control from this group.\n   *\n   * @param name The control name to remove from the collection\n   */\n  override removeControl<K extends StringKeys<T>>(name: K) {\n    return super.removeControl(name);\n  }\n\n  /**\n   * Replace an existing control.\n   *\n   * @param name The control name to replace in the collection\n   * @param control Provides the control for the given name\n   */\n  override setControl<\n    K extends StringKeys<T>,\n    CV extends object = ValidatorsModel\n  >(name: K, control: ControlType<T[K], CV>) {\n    return super.setControl(name, control);\n  }\n\n  /**\n   * Check whether there is an enabled control with the given name in the group.\n   *\n   * Reports false for disabled controls. If you'd like to check for existence in the group\n   * only, use [get](https://angular.io/api/forms/AbstractControl#get) instead.\n   *\n   * @param name The control name to check for existence in the collection\n   *\n   * @returns false for disabled controls, true otherwise.\n   */\n  override contains<K extends StringKeys<T>>(name: K) {\n    return super.contains(name);\n  }\n\n  /**\n   * Sets the value of the `FormGroup`. It accepts an object that matches\n   * the structure of the group, with control names as keys.\n   *\n   * ### Set the complete value for the form group\n   *\n```ts\nconst form = new FormGroup({\n  first: new FormControl(),\n  last: new FormControl()\n});\n\nconsole.log(form.value);   // {first: null, last: null}\n\nform.setValue({first: 'Nancy', last: 'Drew'});\nconsole.log(form.value);   // {first: 'Nancy', last: 'Drew'}\n```\n   *\n   * @throws When strict checks fail, such as setting the value of a control\n   * that doesn't exist or if you excluding the value of a control.\n   *\n   * @param value The new value for the control that matches the structure of the group.\n   * @param options Configuration options that determine how the control propagates changes\n   * and emits events after the value changes.\n   * The configuration options are passed to the\n   * [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.\n   *\n   * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is\n   * false.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges`\n   * observables emit events with the latest status and value when the control value is updated.\n   * When false, no events are emitted.\n   */\n  override setValue(\n    value: ExtractGroupValue<T>,\n    options: { onlySelf?: boolean; emitEvent?: boolean } = {}\n  ) {\n    return super.setValue(value, options);\n  }\n\n  /**\n   * Patches the value of the `FormGroup`. It accepts an object with control\n   * names as keys, and does its best to match the values to the correct controls\n   * in the group.\n   *\n   * It accepts both super-sets and sub-sets of the group without throwing an error.\n   *\n   * ### Patch the value for a form group\n   *\n```ts\nconst form = new FormGroup({\n   first: new FormControl(),\n   last: new FormControl()\n});\nconsole.log(form.value);   // {first: null, last: null}\n\nform.patchValue({first: 'Nancy'});\nconsole.log(form.value);   // {first: 'Nancy', last: null}\n```\n   *\n   * @param value The object that matches the structure of the group.\n   * @param options Configuration options that determine how the control propagates changes and\n   * emits events after the value is patched.\n   * * `onlySelf`: When true, each change only affects this control and not its parent. Default is\n   * true.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges`\n   * observables emit events with the latest status and value when the control value is updated.\n   * When false, no events are emitted.\n   * The configuration options are passed to the\n   * [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.\n   */\n  override patchValue(\n    value: Partial<ExtractGroupValue<T>>,\n    options: { onlySelf?: boolean; emitEvent?: boolean } = {}\n  ) {\n    return super.patchValue(value, options);\n  }\n\n  /**\n   * Resets the `FormGroup`, marks all descendants are marked `pristine` and `untouched`, and\n   * the value of all descendants to null.\n   *\n   * You reset to a specific form state by passing in a map of states\n   * that matches the structure of your form, with control names as keys. The state\n   * is a standalone value or a form state object with both a value and a disabled\n   * status.\n   *\n   * @param formState Resets the control with an initial value,\n   * or an object that defines the initial value and disabled state.\n   *\n   * @param options Configuration options that determine how the control propagates changes\n   * and emits events when the group is reset.\n   * * `onlySelf`: When true, each change only affects this control, and not its parent. Default is\n   * false.\n   * * `emitEvent`: When true or not supplied (the default), both the `statusChanges` and\n   * `valueChanges`\n   * observables emit events with the latest status and value when the control is reset.\n   * When false, no events are emitted.\n   * The configuration options are passed to the\n   * [updateValueAndValidity](https://angular.io/api/forms/AbstractControl#updateValueAndValidity) method.\n   *\n   *\n   * ### Reset the form group values\n   *\n```ts\nconst form = new FormGroup({\n  first: new FormControl('first name'),\n  last: new FormControl('last name')\n});\n\nconsole.log(form.value);  // {first: 'first name', last: 'last name'}\n\nform.reset({ first: 'name', last: 'last name' });\n\nconsole.log(form.value);  // {first: 'name', last: 'last name'}\n```\n   *\n   * ### Reset the form group values and disabled status\n   *\n```ts\nconst form = new FormGroup({\n  first: new FormControl('first name'),\n  last: new FormControl('last name')\n});\n\nform.reset({\n  first: {value: 'name', disabled: true},\n  last: 'last'\n});\n\nconsole.log(this.form.value);  // {first: 'name', last: 'last name'}\nconsole.log(this.form.get('first').status);  // 'DISABLED'\n```\n   */\n  override reset(\n    value: ExtractGroupValue<T> = {} as any,\n    options: { onlySelf?: boolean; emitEvent?: boolean } = {}\n  ) {\n    return super.reset(value, options);\n  }\n\n  /**\n   * The aggregate value of the `FormGroup`, including any disabled controls.\n   *\n   * Retrieves all values regardless of disabled status.\n   * The `value` property is the best way to get the value of the group, because\n   * it excludes disabled controls in the `FormGroup`.\n   */\n  override getRawValue() {\n    return super.getRawValue() as ExtractGroupValue<T>;\n  }\n\n  /**\n   * Retrieves a child control given the control's name.\n   *\n   * ### Retrieve a nested control\n   *\n   * For example, to get a `name` control nested within a `person` sub-group:\n```ts\nthis.form.get('person').get('name');\n```\n   */\n  override get<K extends StringKeys<T>, CV extends object = ValidatorsModel>(\n    controlName: K\n  ): ControlType<T[K], CV> | null {\n    return super.get(controlName) as ControlType<T[K], CV> | null;\n  }\n\n  /**\n   * Sets the synchronous validators that are active on this control. Calling\n   * this overwrites any existing sync validators.\n   */\n  override setValidators(newValidator: ValidatorFn | ValidatorFn[] | null) {\n    return super.setValidators(newValidator);\n  }\n\n  /**\n   * Sets the async validators that are active on this control. Calling this\n   * overwrites any existing async validators.\n   */\n  override setAsyncValidators(\n    newValidator: AsyncValidatorFn | AsyncValidatorFn[] | null\n  ) {\n    return super.setAsyncValidators(newValidator);\n  }\n\n  /**\n   * Sets errors on a form control when running validations manually, rather than automatically.\n   *\n   * Calling `setErrors` also updates the validity of the parent control.\n   *\n   * ### Manually set the errors for a control\n   *\n   * ```ts\n   * const login = new FormControl('someLogin');\n   * login.setErrors({\n   *   notUnique: true\n   * });\n   *\n   * expect(login.valid).toEqual(false);\n   * expect(login.errors).toEqual({ notUnique: true });\n   *\n   * login.setValue('someOtherLogin');\n   *\n   * expect(login.valid).toEqual(true);\n   * ```\n   */\n  override setErrors(\n    errors: ValidationErrors | null,\n    opts: { emitEvent?: boolean } = {}\n  ) {\n    return super.setErrors(errors, opts);\n  }\n\n  /**\n   * Reports error data for the control with the given controlName.\n   *\n   * @param errorCode The code of the error to check\n   * @param controlName A control name that designates how to move from the current control\n   * to the control that should be queried for errors.\n   *\n   * For example, for the following `FormGroup`:\n   *\n```ts\nform = new FormGroup({\n  address: new FormGroup({ street: new FormControl() })\n});\n```\n   *\n   * The controlName to the 'street' control from the root form would be 'address' -> 'street'.\n   *\n   * It can be provided to this method in combination with `get()` method:\n   *\n```ts\nform.get('address').getError('someErrorCode', 'street');\n```\n   *\n   * @returns error data for that particular error. If the control or error is not present,\n   * null is returned.\n   */\n  override getError<P extends StringKeys<V>, K extends StringKeys<T>>(\n    errorCode: P,\n    controlName?: K\n  ) {\n    return super.getError(errorCode, controlName) as V[P] | null;\n  }\n\n  /**\n   * Reports whether the control with the given controlName has the error specified.\n   *\n   * @param errorCode The code of the error to check\n   * @param controlName A control name that designates how to move from the current control\n   * to the control that should be queried for errors.\n   *\n   * For example, for the following `FormGroup`:\n   *\n```ts\nform = new FormGroup({\n  address: new FormGroup({ street: new FormControl() })\n});\n```\n   *\n   * The controlName to the 'street' control from the root form would be 'address' -> 'street'.\n   *\n   * It can be provided to this method in combination with `get()` method:\n```ts\nform.get('address').hasError('someErrorCode', 'street');\n```\n   *\n   * If no controlName is given, this method checks for the error on the current control.\n   *\n   * @returns whether the given error is present in the control at the given controlName.\n   *\n   * If the control is not present, false is returned.\n   */\n  override hasError<P extends StringKeys<V>, K extends StringKeys<T>>(\n    errorCode: P,\n    controlName?: K\n  ) {\n    return super.hasError(errorCode, controlName);\n  }\n}\n"]}