react-immutable-proptypes - npm Package Compare versions

Comparing version 1.7.2 to 2.0.0

CHANGELOG.md

@@ -0,1 +1,4 @@
+## 2.0.0
+  - [Aldredcz](https://github.com/Aldredcz) made map key validation happen
+
 ## 1.7.2
@@ -2,0 +5,0 @@ - [Lexicality](https://github.com/Lexicality) added support for Immutable > 3.6.2

dist/ImmutablePropTypes.js

@@ -113,2 +113,21 @@ /**
 
+function createKeysTypeChecker(typeChecker) {
+
+  function validate(props, propName, componentName, location, propFullName) {
+    var propValue = props[propName];
+    if (typeof typeChecker !== "function") {
+      return new Error("Invalid keysTypeChecker (optional second argument) supplied to `" + componentName + "` " + ("for propType `" + propFullName + "`, expected a function."));
+    }
+
+    var keys = propValue.keySeq().toArray();
+    for (var i = 0, len = keys.length; i < len; i++) {
+      var error = typeChecker(keys, i, componentName, location, "" + propFullName + " -> key(" + keys[i] + ")");
+      if (error instanceof Error) {
+        return error;
+      }
+    }
+  }
+  return createChainableTypeChecker(validate);
+}
+
 function createListOfTypeChecker(typeChecker) {
@@ -118,10 +137,22 @@ return createIterableTypeChecker(typeChecker, "List", Immutable.List.isList);
 
-function createMapOfTypeChecker(typeChecker) {
-  return createIterableTypeChecker(typeChecker, "Map", Immutable.Map.isMap);
+function createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, immutableClassName, immutableClassTypeValidator) {
+  function validate() {
+    for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+
+    return createIterableTypeChecker(valuesTypeChecker, immutableClassName, immutableClassTypeValidator).apply(undefined, args) || keysTypeChecker && createKeysTypeChecker(keysTypeChecker).apply(undefined, args);
+  }
+
+  return createChainableTypeChecker(validate);
 }
 
-function createOrderedMapOfTypeChecker(typeChecker) {
-  return createIterableTypeChecker(typeChecker, "OrderedMap", Immutable.OrderedMap.isOrderedMap);
+function createMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
+  return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, "Map", Immutable.Map.isMap);
 }
 
+function createOrderedMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
+  return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, "OrderedMap", Immutable.OrderedMap.isOrderedMap);
+}
+
 function createSetOfTypeChecker(typeChecker) {
@@ -128,0 +159,0 @@ return createIterableTypeChecker(typeChecker, "Set", Immutable.Set.isSet);

package.json

 {
   "name": "react-immutable-proptypes",
-  "version": "1.7.2",
+  "version": "2.0.0",
   "description": "PropType validators that work with Immutable.js.",
@@ -5,0 +5,0 @@ "main": "dist/ImmutablePropTypes.js",

README.md

@@ -67,8 +67,40 @@ # react-immutable-proptypes
 
+* `ImmutablePropTypes.contains` (formerly `shape`) is based on `React.PropTypes.shape` and will try to work with any `Immutable.Iterable`. In my usage it is the most used validator, as I'm often trying to validate that a map has certain properties with certain values.
+
+```es6
+// ...
+aMap: ImmutablePropTypes.contains({
+    aList: ImmutablePropTypes.contains({
+        0: React.PropTypes.number,
+        1: React.PropTypes.string,
+        2: React.PropTypes.number.isRequired,
+    }).isRequired,
+})
+// ...
+<SomeComponent aList={Immutable.fromJS({aList: [1, 'two', 3]})} />
+```
+
 * `ImmutablePropTypes.listOf` is based on `React.PropTypes.array` and is specific to `Immutable.List`.
 
-* `ImmutablePropTypes.mapOf` is basically the same as `listOf`, but it is specific to `Immutable.Map` It will check that the prop is an Immutable.Map and that the values are of the specified type.
+* `ImmutablePropTypes.mapOf` allows you to control both map values nad keys (in Immutable.Map, keys could be _anything_ including another Immutable collections). It accepts two arguments - first one for values, second one for keys (optional). If you are interested in validation of keys only, just pass `React.PropTypes.any` as the first argument.
 
-* `ImmutablePropTypes.orderedMapOf` is basically the same as `listOf`, but it is specific to `Immutable.OrderedMap`.
+```es6
+// ...
+aMap: ImmutablePropTypes.mapOf(
+    React.PropTypes.any, // validation for values
+    ImmutablePropTypes.mapContains({ // validation for keys
+        a: React.PropTypes.number.isRequired,
+        b: React.PropTypes.string
+    })
+)
+// ...
+const aMap = Immutable.Map([
+    [Immutable.Map({a: 1, b: '2'}), 'foo'],
+    [Immutable.Map({a: 3}), [1, '2', 3]]
+]);
+<SomeComponent aMap={aMap} />
+```
 
+* `ImmutablePropTypes.orderedMapOf` is basically the same as `mapOf`, but it is specific to `Immutable.OrderedMap`.
+
 * `ImmutablePropTypes.orderedSetOf` is basically the same as `listOf`, but it is specific to `Immutable.OrderedSet`.
@@ -91,17 +123,2 @@
 
-* `ImmutablePropTypes.contains` (formerly `shape`) is based on `React.PropTypes.shape` and will try to work with any `Immutable.Iterable`. In practice, I would recommend limiting this to `Immutable.Map` or `Immutable.OrderedMap`. However, it is possible to abuse `contains` to validate an array via `Immutable.List`. That said, please, just... don't.
-
-```es6
-// ...
-aMap: ImmutablePropTypes.contains({
-    aList: ImmutablePropTypes.contains({
-        0: React.PropTypes.number,
-        1: React.PropTypes.string,
-        2: React.PropTypes.number.isRequired,
-    }).isRequired,
-})
-// ...
-<SomeComponent aList={Immutable.fromJS({aList: [1, 'two', 3]})} />
-```
-
 * `ImmutablePropTypes.mapContains` is based on `React.PropTypes.shape` and will only work with `Immutable.Map`.
@@ -108,0 +125,0 @@

src/ImmutablePropTypes.js

@@ -121,2 +121,24 @@ /**
 
+function createKeysTypeChecker(typeChecker) {
+
+  function validate(props, propName, componentName, location, propFullName) {
+    var propValue = props[propName];
+    if (typeof typeChecker !== 'function') {
+      return new Error(
+          `Invalid keysTypeChecker (optional second argument) supplied to \`${componentName}\` ` +
+          `for propType \`${propFullName}\`, expected a function.`
+      );
+    }
+
+    var keys = propValue.keySeq().toArray();
+    for (var i = 0, len = keys.length; i < len; i++) {
+      var error = typeChecker(keys, i, componentName, location, `${propFullName} -> key(${keys[i]})`);
+      if (error instanceof Error) {
+        return error;
+      }
+    }
+  }
+  return createChainableTypeChecker(validate);
+}
+
 function createListOfTypeChecker(typeChecker) {
@@ -126,10 +148,19 @@ return createIterableTypeChecker(typeChecker, 'List', Immutable.List.isList);
 
-function createMapOfTypeChecker(typeChecker) {
-  return createIterableTypeChecker(typeChecker, 'Map', Immutable.Map.isMap);
+function createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, immutableClassName, immutableClassTypeValidator) {
+  function validate(...args) {
+    return createIterableTypeChecker(valuesTypeChecker, immutableClassName, immutableClassTypeValidator)(...args)
+        || keysTypeChecker && createKeysTypeChecker(keysTypeChecker)(...args)
+  }
+
+  return createChainableTypeChecker(validate);
 }
 
-function createOrderedMapOfTypeChecker(typeChecker) {
-  return createIterableTypeChecker(typeChecker, 'OrderedMap', Immutable.OrderedMap.isOrderedMap);
+function createMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
+  return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, 'Map', Immutable.Map.isMap);
 }
 
+function createOrderedMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
+  return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, 'OrderedMap', Immutable.OrderedMap.isOrderedMap);
+}
+
 function createSetOfTypeChecker(typeChecker) {
@@ -136,0 +167,0 @@ return createIterableTypeChecker(typeChecker, 'Set', Immutable.Set.isSet);

No alert changes

Improved metrics

Total package byte prevSize

28628

increased by12.53%

Lines of code

411

increased by14.17%

Number of lines in readme file

138

increased by14.05%

No dependency changes