ngrx-forms
Version:
Proper integration of forms in Angular 4 applications using ngrx
57 lines • 6.26 kB
JavaScript
import { unbox } from 'ngrx-forms';
/**
* A validation function that requires a `string` or `array` value to have a minimum length.
* Considers `null`, `undefined`, empty strings and empty arrays as valid. Combine this
* function with the `required` validation function if these values should be considered invalid.
*
* The validation error returned by this validation function has the following shape:
*
```typescript
{
minLength: {
minLength: number;
value: string;
actualLength: number;
};
}
```
*
* Usually you would use this validation function in conjunction with the `validate`
* update function to perform synchronous validation in your reducer:
*
```typescript
updateGroup<MyFormValue>({
password: validate(minLength(8)),
})
```
*
* Note that this function is generic to allow the compiler to properly infer the type
* of the `validate` function for both optional and non-optional controls.
*/
export function minLength(minLengthParam) {
// tslint:disable-next-line:strict-type-predicates (guard for users without strict type checking)
if (minLengthParam === null || minLengthParam === undefined) {
throw new Error(`The minLength Validation function requires the minLength parameter to be a non-null number, got ${minLengthParam}!`);
}
return (value) => {
value = unbox(value);
if (value === null || value === undefined) {
return {};
}
const length = value.length;
if (length === 0) {
return {}; // don't validate empty values to allow optional controls
}
if (length >= minLengthParam) {
return {};
}
return {
minLength: {
minLength: minLengthParam,
value: value,
actualLength: length,
},
};
};
}
//# sourceMappingURL=data:application/json;base64,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