react-immutable-proptypes

npm package Code Climate Test Coverage

PropType validators that work with Immutable.js.

About

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.

  1. var ImmutablePropTypes = require('react-immutable-proptypes');
  2. var MyReactComponent = React.createClass({
  3.     // ...
  4.     propTypes: {
  5.         myRequiredImmutableList: ImmutablePropTypes.listOf(
  6.             ImmutablePropTypes.contains({
  7.                 someNumberProp: React.PropTypes.number.isRequired
  8.             })
  9.         ).isRequired
  10.     }
  11.     // ...
  12. });

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

  1. propTypes: {
  2.     oldListTypeChecker: React.PropTypes.instanceOf(Immutable.List),
  3.     anotherWay: ImmutablePropTypes.list,
  4.     requiredList: ImmutablePropTypes.list.isRequired,
  5.     mapsToo: ImmutablePropTypes.map,
  6.     evenIterable: ImmutablePropTypes.iterable
  7. }

Installation

Installing via npmjs

  1. npm install --save react-immutable-proptypes

API

React-Immutable-PropTypes has:

  • Primitive Types

    1. ImmutablePropTypes.list         // Immutable.List.isList
    2. ImmutablePropTypes.map          // Immutable.Map.isMap
    3. ImmutablePropTypes.orderedMap   // Immutable.OrderedMap.isOrderedMap
    4. ImmutablePropTypes.set          // Immutable.Set.isSet
    5. ImmutablePropTypes.orderedSet   // Immutable.OrderedSet.isOrderedSet
    6. ImmutablePropTypes.stack        // Immutable.Stack.isStack
    7. ImmutablePropTypes.seq          // Immutable.Seq.isSeq
    8. ImmutablePropTypes.iterable     // Immutable.Iterable.isIterable
    9. ImmutablePropTypes.record       // instanceof Record
    10. ImmutablePropTypes.contains     // Immutable.Iterable.isIterable - contains(shape)
    11. ImmutablePropTypes.mapContains  // Immutable.Map.isMap - contains(shape)

  • 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.

  1. // ...
  2. aMap: ImmutablePropTypes.contains({
  3.     aList: ImmutablePropTypes.contains({
  4.         0: React.PropTypes.number,
  5.         1: React.PropTypes.string,
  6.         2: React.PropTypes.number.isRequired,
  7.     }).isRequired,
  8. })
  9. // ...
  10. <SomeComponent aList={Immutable.fromJS({aList: [1, 'two', 3]})} />

  • ImmutablePropTypes.listOf is based on React.PropTypes.array and is specific to Immutable.List.

  • 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.

  1. // ...
  2. aMap: ImmutablePropTypes.mapOf(
  3.     React.PropTypes.any, // validation for values
  4.     ImmutablePropTypes.mapContains({ // validation for keys
  5.         a: React.PropTypes.number.isRequired,
  6.         b: React.PropTypes.string
  7.     })
  8. )
  9. // ...
  10. const aMap = Immutable.Map([
  11.     [Immutable.Map({a: 1, b: '2'}), 'foo'],
  12.     [Immutable.Map({a: 3}), [1, '2', 3]]
  13. ]);
  14. <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.

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

  • ImmutablePropTypes.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.

  1. // ...
  2. aRecord: ImmutablePropTypes.recordOf({
  3.     keyA: React.PropTypes.string,
  4.     keyB: ImmutablePropTypes.list.isRequired
  5. })
  6. // ...
  • ImmutablePropTypes.mapContains is based on React.PropTypes.shape and will only work with Immutable.Map.
  1. // ...
  2. aMap: ImmutablePropTypes.mapContains({
  3.     aList: ImmutablePropTypes.list.isRequired,
  4. })
  5. // ...
  6. <SomeComponent aList={Immutable.fromJS({aList: [1, 2]})} />

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

RFC

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.