Loose ramda typings

package.json

@@ -8,7 +8,7 @@
         "build": "npm-run-all --parallel build:*",
         "build:main": "babel src --out-dir lib --ignore '**/__tests__/**'",
         "build:umd": "webpack --output-filename index.umd.js -p",
-        "build:flow": "babel-flow src --out-dir lib",
+        "build:flow": "babel-flow src --out-dir lib --ignore '**/__tests__/**'",
         "flow": "flow check",
         "test": "jest --watch",
         "test:ci": "jest --coverage && codecov",

src/__tests__/fieldValidators.js

@@ -167,4 +167,5 @@ it('isBetween', () => {
     expect(isBetweenZeroAndTen(10)).toBe(null);
     expect(isBetweenZeroAndTen(-1)).toBe('wrongValue');
     expect(isBetweenZeroAndTen(11)).toBe('wrongValue');
+    expect(isBetweenZeroAndTen(null)).toBe(null);
 });

src/createValidation.js

@@ -1,13 +1,17 @@
 // @flow
-import R from 'ramda';
+import Ramda from 'ramda';
 
 import type { ErrorT } from './validateModel';
 
+// ramda flow-typed typings are not always correct, and use Array, while this library uses
+// $ReadOnlyArray
+const R: any = Ramda;
+
 function createValidation<M, T>(
     field: string,
     getField: (model: M) => T,
     validateField: (field: T) => string | null,
-): (M) => ErrorT | null {
+): M => ErrorT | null {
     return R.pipe(getField, validateField, R.when(Boolean, error => ({ field, error })));
 }
 

src/createValidations.js

@@ -1,11 +1,15 @@
 // @flow
-import R from 'ramda';
+import Ramda from 'ramda';
 
 import createValidation from './createValidation';
 import { testMissingValue } from './fieldValidators';
 import type { ErrorT } from './validateModel';
 import type { CreateSimpleValidation, CreateNestedValidation } from './types';
 
+// ramda flow-typed typings are not always correct, and use Array, while this library uses
+// $ReadOnlyArray
+const R: any = Ramda;
+
 const createNestedValidation: CreateNestedValidation = R.curry(
     (validateField: () => string | null, fieldPath: $ReadOnlyArray<string>) =>
         createValidation(fieldPath.join('.'), R.path(fieldPath), validateField),

src/fieldValidators.js

@@ -86,11 +86,14 @@ const checkMaxLength = R.curry(
 
 /**
   * @desc Test if a number is contained between two others (included)
-  * @param {?number} value - The array or string
-  * @return {?string} 'wrongValue' if the value is outside of the boundaries, null if not
+  * @param {number} min - The lower bound (exluded)
+  * @param {number} max - The upper bound (excluded)
+  * @param {?number} value - The value to test
+  * @return {?string} 'input' if the value is outside of the boundaries, null if not
   */
 const isBetween = R.curry(
-    (min: number, max: number, input) => (input < min || input > max ? 'wrongValue' : null),
+    (min: number, max: number, input: ?number) =>
+        typeof input === 'number' && (input < min || input > max) ? 'wrongValue' : null,
 );
 
 export {

src/getFieldError.js

@@ -1,19 +1,16 @@
 // @flow
-import R from 'ramda';
 import type { ErrorT } from './validateModel';
 
 const getFieldError = (errors: $ReadOnlyArray<ErrorT>) => (field: string): $ReadOnlyArray<string> =>
-    errors.filter(R.propEq('field', field)).map(R.prop('error'));
+    errors.filter(error => error.field === field).map(error => error.error);
 
 const getFieldSpecificErrors = (
     errors: $ReadOnlyArray<ErrorT>,
     fieldName: string,
 ): $ReadOnlyArray<ErrorT> =>
     errors.filter(({ field, error }) => field === fieldName && error !== 'missing');
 
-const fieldHasSpecificErrors: (
-    errors: $ReadOnlyArray<ErrorT>,
-    fieldName: string,
-) => boolean = R.pipe(getFieldSpecificErrors, R.isEmpty, R.not);
+const fieldHasSpecificErrors = (errors: $ReadOnlyArray<ErrorT>, fieldName: string): boolean =>
+    getFieldSpecificErrors(errors, fieldName).length > 0;
 
 export { fieldHasSpecificErrors, getFieldError, getFieldSpecificErrors };

src/validateModel.js

@@ -1,5 +1,9 @@
 // @flow
-import R from 'ramda';
+import Ramda from 'ramda';
+
+// ramda flow-typed typings are not always correct, and use Array, while this library uses
+// $ReadOnlyArray
+const R: any = Ramda;
 
 export type ErrorT = { field: string, error: string };
 type MaybeErrorT = ErrorT | null;