ngrx-forms
Version:
Proper integration of forms in Angular 4 applications using ngrx
51 lines • 5.43 kB
JavaScript
import { unbox } from 'ngrx-forms';
/**
* A validation function that requires the value to be less than a number.
* Considers `null`, `undefined` and non-numeric values as valid. Combine this function with the `required`
* validation function if `null` or `undefined` should be considered invalid.
*
* The validation error returned by this validation function has the following shape:
*
```typescript
{
lessThan: {
comparand: number;
actual: 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>({
amount: validate(lessThan(10)),
})
```
*
* 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 lessThan(comparand) {
// tslint:disable-next-line:strict-type-predicates (guard for users without strict type checking)
if (comparand === null || comparand === undefined) {
throw new Error(`The lessThan Validation function requires the comparand parameter to be a non-null number, got ${comparand}!`);
}
return (value) => {
value = unbox(value);
if (value === null || value === undefined || typeof value !== 'number') {
return {};
}
if (value < comparand) {
return {};
}
return {
lessThan: {
comparand,
actual: value,
},
};
};
}
//# sourceMappingURL=data:application/json;base64,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