PropType validators that work with Immutable.js. 

hurricanejames

react-immutable-proptypes

  - thanks to [Alon Gubkin](https://github.com/alongubkin) for writing the `stackOf` type checker.

  - try to specify which Immutable data structure was provided instead of saying `object`.

   - added support for orderedSetOf and orderedMapOf

  - added support for record and recordOf type checkers.

- 1.2.3 [Nik Butenko](http://butenko.me/) provided a better .npmignore file

  - allows devs who want to compile the code to do so

  - better excludes files that are not needed for distribution

- 1.2.2 [Nik Butenko](http://butenko.me/) gave us some nice updates ()

  - [Issue #10](https://github.com/HurricaneJames/react-immutable-proptypes/pull/10) now have better errors when typechecker(s) provided in `propTypes` definition is invalid

  - [Issue #9](https://github.com/HurricaneJames/react-immutable-proptypes/pull/9) removed use of `new` Immutable objects in tests

- 1.2.1 updated documentation to reflect that Immutable object instantiation does not require `new`

- 1.2.0 moved react from peer dependency to dev dependency since React is only used internally to test. This will allow the prop type validators to work on beta/rc versions of react.

- 1.1.0 added `contains` to replace `shape` validator. `shape` is deprecated and will be removed in v 1.2.0

- 1.0.0 marked as stable, no other changes

- 0.1.8 added `setOf` checker. Thanks to [Don Abrams](https://github.com/donabrams)!

- 0.1.7 added convencience checkers for "primitive" immutable types (map, list, etc...)

- 0.1.3 updated package.json to support React v0.11.0+ (including 0.13.1). Thanks [Andrey Okonetchnikov](https://github.com/okonet)!

 * This is a straight rip-off of the React.js ReactPropTypes.js proptype validators,

 * modified to make it possible to validate Immutable.js data.

 *     ImmutableTypes.listOf is patterned after React.PropTypes.arrayOf, but for Immutable.List

 *     ImmutableTypes.shape  is based on React.PropTypes.shape, but for any Immutable.Iterable

  orderedMapOf: createOrderedMapOfTypeChecker,

  orderedSetOf: createOrderedSetOfTypeChecker,

  iterableOf: createIterableOfTypeChecker,

  list: createImmutableTypeChecker("List", Immutable.List.isList),

  map: createImmutableTypeChecker("Map", Immutable.Map.isMap),

  orderedMap: createImmutableTypeChecker("OrderedMap", Immutable.OrderedMap.isOrderedMap),

  set: createImmutableTypeChecker("Set", Immutable.Set.isSet),

  orderedSet: createImmutableTypeChecker("OrderedSet", Immutable.OrderedSet.isOrderedSet),

  stack: createImmutableTypeChecker("Stack", Immutable.Stack.isStack),

  seq: createImmutableTypeChecker("Seq", Immutable.Seq.isSeq),

  record: createImmutableTypeChecker("Record", function (isRecord) {

    return isRecord instanceof Immutable.Record;

  iterable: createImmutableTypeChecker("Iterable", Immutable.Iterable.isIterable)

    // Old webkits (at least until Android 4.0) return 'function' rather than

    // 'object' for typeof a RegExp. We'll normalize this here so that /bla/

  if (propValue instanceof Immutable.Iterable) {

    return "Immutable." + propValue.toSource().split(" ")[0];

function createChainableTypeChecker(validate) {

  function checkType(isRequired, props, propName, componentName, location) {

    componentName = componentName || ANONYMOUS;

        return new Error("Required " + locationName + " `" + propName + "` was not specified in " + ("`" + componentName + "`."));

      return validate(props, propName, componentName, location);

  var chainedCheckType = checkType.bind(null, false);

  chainedCheckType.isRequired = checkType.bind(null, true);

function createImmutableTypeChecker(immutableClassName, immutableClassTypeValidator) {

  function validate(props, propName, componentName, location) {

    if (!immutableClassTypeValidator(propValue)) {

      var propType = getPropType(propValue);

      return new Error("Invalid " + location + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `" + immutableClassName + "`."));

  return createChainableTypeChecker(validate);

function createIterableTypeChecker(typeChecker, immutableClassName, immutableClassTypeValidator) {

      return new Error("Invalid " + locationName + " `" + propName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an Immutable.js " + immutableClassName + "."));

    if (typeof typeChecker !== "function") {

      return new Error("Invalid typeChecker supplied to `" + componentName + "` " + ("for propType `" + propName + "`, expected a function."));

    var propValues = propValue.toArray();

    for (var i = 0, len = propValues.length; i < len; i++) {

      var error = typeChecker(propValues, i, componentName, location);

function createListOfTypeChecker(typeChecker) {

  return createIterableTypeChecker(typeChecker, "List", Immutable.List.isList);

function createMapOfTypeChecker(typeChecker) {

  return createIterableTypeChecker(typeChecker, "Map", Immutable.Map.isMap);

function createOrderedMapOfTypeChecker(typeChecker) {

  return createIterableTypeChecker(typeChecker, "OrderedMap", Immutable.OrderedMap.isOrderedMap);

function createStackOfTypeChecker(typeChecker) {

  return createIterableTypeChecker(typeChecker, "Stack", Immutable.Stack.isStack);

function createIterableOfTypeChecker(typeChecker) {

  return createIterableTypeChecker(typeChecker, "Iterable", Immutable.Iterable.isIterable);

function createRecordOfTypeChecker(recordKeys) {

    var propType = getPropType(propValue);

    if (!(propValue instanceof Immutable.Record)) {

      return new Error("Invalid " + locationName + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected an Immutable.js Record."));

      var mutablePropValue = propValue.toObject();

      var error = checker(mutablePropValue, key, componentName, location);

// there is some irony in the fact that shapeTypes is a standard hash and not an immutable collection

function createShapeTypeChecker(shapeTypes) {

    if (!Immutable.Iterable.isIterable(propValue)) {

      return new Error("Invalid " + locationName + " `" + propName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected an Immutable.js Iterable."));

  "description": "PropType validators that work with Immutable.js.",

    "lint": "./node_modules/.bin/eslint ./src"

    "url": "https://github.com/HurricaneJames/react-immutable-proptypes"

  "author": "James Burnett <HurricaneJamesEsq@gmail.com> (https://github.com/HurricaneJames/react-immutable-proptypes)",

    "url": "https://github.com/HurricaneJames/react-immutable-proptypes/issues"

  "homepage": "https://github.com/HurricaneJames/react-immutable-proptypes",

[![npm package](https://img.shields.io/npm/v/react-immutable-proptypes.svg?style=flat)](https://www.npmjs.org/package/react-immutable-proptypes) [![Code Climate](https://codeclimate.com/github/HurricaneJames/react-immutable-proptypes/badges/gpa.svg)](https://codeclimate.com/github/HurricaneJames/react-immutable-proptypes) [![Test Coverage](https://codeclimate.com/github/HurricaneJames/react-immutable-proptypes/badges/coverage.svg)](https://codeclimate.com/github/HurricaneJames/react-immutable-proptypes)

I got tired of seeing `React.PropTypes.instanceOf(Immutable.List)` or `React.PropTypes.instanceOf(Immutable.Map)` as PropTypes for components that should be specifying an `Immutable.List` **_of_** something or that an `Immutable.Map` **contains** some keys. A little *"googling"* came up empty, unless you want to use Flow, which I do not. So, I wrote `react-immutable-proptypes`.

Usage is simple, they work with and like any `React.PropType.*` validator.

var ImmutablePropTypes = require('react-immutable-proptypes');

var MyReactComponent = React.createClass({

        myRequiredImmutableList: ImmutablePropTypes.listOf(

            ImmutablePropTypes.contains({

                someNumberProp: React.PropTypes.number.isRequired

Since version 0.1.7 there are convenience helpers for "primitive" Immutable.js objects.

    oldListTypeChecker: React.PropTypes.instanceOf(Immutable.List),

    requiredList: ImmutablePropTypes.list.isRequired,

    evenIterable: ImmutablePropTypes.iterable

Installing via [npmjs](https://www.npmjs.com/package/react-immutable-proptypes)

npm install --save react-immutable-proptypes

ImmutablePropTypes.list         // Immutable.List.isList

ImmutablePropTypes.map          // Immutable.Map.isMap

ImmutablePropTypes.orderedMap   // Immutable.OrderedMap.isOrderedMap

ImmutablePropTypes.set          // Immutable.Set.isSet

ImmutablePropTypes.orderedSet   // Immutable.OrderedSet.isOrderedSet

ImmutablePropTypes.stack        // Immutable.Stack.isStack

ImmutablePropTypes.seq          // Immutable.Seq.isSeq

ImmutablePropTypes.iterable     // Immutable.Iterable.isIterable

ImmutablePropTypes.record       // instanceof Record

* `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`.

* `ImmutablePropTypes.orderedMapOf` is basically the same as `listOf`, but it is specific to `Immutable.OrderedMap`.

* `ImmutablePropTypes.orderedSetOf` is basically the same as `listOf`, but it is specific to `Immutable.OrderedSet`.

* `ImmutablePropTypes.stackOf` is basically the same as `listOf`, but it is specific to `Immutable.Stack`.

* `ImmutbalePropTypes.iterableOf` is the generic form of listOf/mapOf. It is useful when there is no need to validate anything other than Immutable.js compatible (ie. `Immutable.Iterable`). Continue to use `listOf` and/or `mapOf` when you know the type.

* `ImmutablePropTypes.recordOf` is like `contains`, except it operates on Record properties.

    keyB: ImmutablePropTypes.list.isRequired

* `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`.

    0: React.PropTypes.number.isRequired,

    1: React.PropTypes.string.isRequired,

That said, don't do this. Please, just... don't.

These two validators cover the output of `Immutable.fromJS` on standard JSON data sources.

Please send a message or, better yet, create an issue/pull request if you know a better solution, find bugs, or want a feature. For example, should `listOf` work with `Immutable.Seq` or `Immutable.Range`. I can think of reasons it should, but it is not a use case I have at the present, so I'm less than inclined to implement it. Alternatively, we could add a validator for sequences and/or ranges.

  stackOf:      createStackOfTypeChecker,

  iterableOf:   createIterableOfTypeChecker,

  recordOf:     createRecordOfTypeChecker,

  list:       createImmutableTypeChecker('List', Immutable.List.isList),

  map:        createImmutableTypeChecker('Map', Immutable.Map.isMap),

  orderedMap: createImmutableTypeChecker('OrderedMap', Immutable.OrderedMap.isOrderedMap),

  set:        createImmutableTypeChecker('Set', Immutable.Set.isSet),

  orderedSet: createImmutableTypeChecker('OrderedSet', Immutable.OrderedSet.isOrderedSet),

  stack:      createImmutableTypeChecker('Stack', Immutable.Stack.isStack),

  seq:        createImmutableTypeChecker('Seq', Immutable.Seq.isSeq),

  record:     createImmutableTypeChecker('Record', function(isRecord) { return isRecord instanceof Immutable.Record; }),

  iterable:   createImmutableTypeChecker('Iterable', Immutable.Iterable.isIterable)

    return 'Immutable.' + propValue.toSource().split(' ')[0];

          `Required ${locationName} \`${propName}\` was not specified in ` +

    if(!immutableClassTypeValidator(propValue)) {

        `Invalid ${location} \`${propName}\` of type \`${propType}\` ` +

        `supplied to \`${componentName}\`, expected \`${immutableClassName}\`.`

        `Invalid ${locationName} \`${propName}\` of type ` +

        `\`${propType}\` supplied to \`${componentName}\`, expected an Immutable.js ${immutableClassName}.`

    if (typeof typeChecker !== 'function') {

        `Invalid typeChecker supplied to \`${componentName}\` ` +

        `for propType \`${propName}\`, expected a function.`

  return createIterableTypeChecker(typeChecker, 'Stack', Immutable.Stack.isStack);

  return createIterableTypeChecker(typeChecker, 'Iterable', Immutable.Iterable.isIterable);

        `Invalid ${locationName} \`${propName}\` of type \`${propType}\` ` +

        `supplied to \`${componentName}\`, expected an Immutable.js Record.`

        `supplied to \`${componentName}\`, expected an Immutable.js Iterable.`

		@@ -0,1 +1,4 @@
		## 1.6.0 added mapContains type checker
		- thanks to [Alon Gubkin](https://github.com/alongubkin) for writing the `stackOf` type checker.

		## 1.5.0 improved warnings
		@@ -2,0 +5,0 @@ - try to specify which Immutable data structure was provided instead of saying `object`.

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

		@@ -19,2 +19,3 @@ /**
		orderedSetOf: createOrderedSetOfTypeChecker,
		stackOf: createStackOfTypeChecker,
		iterableOf: createIterableOfTypeChecker,
		@@ -131,2 +132,6 @@ recordOf: createRecordOfTypeChecker,

		function createStackOfTypeChecker(typeChecker) {
		return createIterableTypeChecker(typeChecker, "Stack", Immutable.Stack.isStack);
		}

		function createIterableOfTypeChecker(typeChecker) {
		@@ -133,0 +138,0 @@ return createIterableTypeChecker(typeChecker, "Iterable", Immutable.Iterable.isIterable);

		@@ -73,2 +73,4 @@ # react-immutable-proptypes

		* `ImmutablePropTypes.stackOf` is basically the same as `listOf`, but it is specific to `Immutable.Stack`.

		* `ImmutbalePropTypes.iterableOf` is the generic form of listOf/mapOf. It is useful when there is no need to validate anything other than Immutable.js compatible (ie. `Immutable.Iterable`). Continue to use `listOf` and/or `mapOf` when you know the type.
		@@ -75,0 +77,0 @@

		@@ -17,2 +17,3 @@ /**
		orderedSetOf: createOrderedSetOfTypeChecker,
		stackOf: createStackOfTypeChecker,
		iterableOf: createIterableOfTypeChecker,
		@@ -139,2 +140,6 @@ recordOf: createRecordOfTypeChecker,

		function createStackOfTypeChecker(typeChecker) {
		return createIterableTypeChecker(typeChecker, 'Stack', Immutable.Stack.isStack);
		}

		function createIterableOfTypeChecker(typeChecker) {
		@@ -141,0 +146,0 @@ return createIterableTypeChecker(typeChecker, 'Iterable', Immutable.Iterable.isIterable);

Improved metrics