Validate immutable objects

[henit]

Is there a way to validate that an array is an immutable array? Like something that would be instanceof for immutable arrays but not for normal mutable arrays.

The use case is actually React.Proptypes validation. Something similar to

propTypes: {
    myobject: React.PropTypes.instanceOf(Immutable.List)
}

I know I can use a custom function in ProtoTypes and use Immutable.isImmutable, but adding a function like that in every component that should receive immutable prop objects, will not be pretty.

[rtfeldman]

There isn't currently. I haven't tried making a custom PropTypes immutability checker, but if it can be done concisely without bringing in React as a dependency, I'd be open to a PR to add it!

[henit]

I have not looked that close at the code yet, so just asking here.

Is there any base object that the immutable objects inherit from? Or is the original objects sent in to the Immutable() function changed directly? If there is some base object available, it could just be used for instanceof check in PropTypes and any other case where it might be required to check if an object is immutable..

Something like

propTypes: {
    myobject: React.PropTypes.instanceOf(Immutable())
}

given that the function without arguments (or something similar) return a base object

[rtfeldman]

That could work with objects, but not with arrays; they need to be instanceof Array in order to be backwards-compatible with normal arrays.

I'm open to adding a helper function intended to be used with React (as long as it doesn't necessitate a React depdendency!) but I don't want to add an extra step to the creation of every single object - even for people using seamless-immutable outside React - for the sake of a React convenience, if that makes sense.

[henit]

Totally understandable. Unfortunately I don't have the time to contribute with the PR myself at the moment, but maybe in the future.

[holyjak]

I guess we want something that can be used like this:

React.createClass({
  propTypes: {
    array: Immutable.PropTypes.array,
    object: Immutable.PropTypes.object
}});```

Then we can simply implement it this way: ```
function validate(type, props, propName, componentName) {
     componentName = comopnentName || 'ANONYMOUS';
      var msg = componentName + ".props." + propName + " is not ";
      if (type === Array && ! (props[propName] instanceof Array)) return new Error(msg + ' an array');
      if (type === Object && (! (props[propName] instanceof Object) || props[propName] instanceof Array)) return new Error(msg + 'an Object');
      if (!Immutable.isImmutable(props[propName])) {
        return new Error(msg + ' immutable');
      }
      return null;
    }
Immutable.PropTypes = {
  array: validate.bind(undefined, Array),
  object: validate.bind(undefined, Object)
};

(If we want to support also .isRequred then we can follow http://www.ian-thomas.net/custom-proptype-validation-with-react/ . Or/and it is possible to combine with the all(...arrayOfValidators) validator from react-prop-types)