Product
Introducing Java Support in Socket
We're excited to announce that Socket now supports the Java programming language.
react-immutable-proptypes
Advanced tools
The react-immutable-proptypes package provides PropTypes validators that are specifically designed to work with Immutable.js data structures. This allows developers to enforce the types of Immutable.js collections in their React components, ensuring that the data passed through props adheres to the expected structure.
List
This feature allows you to validate that a prop is an Immutable.js List. The code sample demonstrates a React component that expects a prop named `myList` to be an Immutable List.
import React from 'react';
import PropTypes from 'prop-types';
import ImmutablePropTypes from 'react-immutable-proptypes';
import { List } from 'immutable';
const MyComponent = ({ myList }) => (
<div>{myList.join(', ')}</div>
);
MyComponent.propTypes = {
myList: ImmutablePropTypes.list
};
export default MyComponent;
Map
This feature allows you to validate that a prop is an Immutable.js Map. The code sample demonstrates a React component that expects a prop named `myMap` to be an Immutable Map.
import React from 'react';
import PropTypes from 'prop-types';
import ImmutablePropTypes from 'react-immutable-proptypes';
import { Map } from 'immutable';
const MyComponent = ({ myMap }) => (
<div>{myMap.get('key')}</div>
);
MyComponent.propTypes = {
myMap: ImmutablePropTypes.map
};
export default MyComponent;
OrderedMap
This feature allows you to validate that a prop is an Immutable.js OrderedMap. The code sample demonstrates a React component that expects a prop named `myOrderedMap` to be an Immutable OrderedMap.
import React from 'react';
import PropTypes from 'prop-types';
import ImmutablePropTypes from 'react-immutable-proptypes';
import { OrderedMap } from 'immutable';
const MyComponent = ({ myOrderedMap }) => (
<div>{myOrderedMap.get('key')}</div>
);
MyComponent.propTypes = {
myOrderedMap: ImmutablePropTypes.orderedMap
};
export default MyComponent;
Set
This feature allows you to validate that a prop is an Immutable.js Set. The code sample demonstrates a React component that expects a prop named `mySet` to be an Immutable Set.
import React from 'react';
import PropTypes from 'prop-types';
import ImmutablePropTypes from 'react-immutable-proptypes';
import { Set } from 'immutable';
const MyComponent = ({ mySet }) => (
<div>{Array.from(mySet).join(', ')}</div>
);
MyComponent.propTypes = {
mySet: ImmutablePropTypes.set
};
export default MyComponent;
The prop-types package is the standard library for type-checking props in React components. While it does not provide specific validators for Immutable.js data structures, it is widely used for general prop type validation in React applications.
The immutable-prop-types package provides PropTypes validators for Immutable.js data structures, similar to react-immutable-proptypes. It offers a similar set of validators for Immutable.js collections, making it a direct alternative.
PropType validators that work with Immutable.js.
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({
// ...
propTypes: {
myRequiredImmutableList: ImmutablePropTypes.listOf(
ImmutablePropTypes.contains({
someNumberProp: React.PropTypes.number.isRequired
})
).isRequired
}
// ...
});
Since version 0.1.7 there are convenience helpers for "primitive" Immutable.js objects.
propTypes: {
oldListTypeChecker: React.PropTypes.instanceOf(Immutable.List),
anotherWay: ImmutablePropTypes.list,
requiredList: ImmutablePropTypes.list.isRequired,
mapsToo: ImmutablePropTypes.map,
evenIterable: ImmutablePropTypes.iterable
}
Installing via npmjs
npm install --save react-immutable-proptypes
React-Immutable-PropTypes has:
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.contains // Immutable.Iterable.isIterable - contains(shape)
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.// ...
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
allows you to control both map values and 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.
// ...
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
.
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.
// ...
aRecord: ImmutablePropTypes.recordOf({
keyA: React.PropTypes.string,
keyB: ImmutablePropTypes.list.isRequired
})
// ...
ImmutablePropTypes.mapContains
is based on React.PropTypes.shape
and will only work with Immutable.Map
.// ...
aMap: ImmutablePropTypes.mapContains({
aList: ImmutablePropTypes.list.isRequired,
})
// ...
<SomeComponent aList={Immutable.fromJS({aList: [1, 2]})} />
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.
FAQs
PropType validators that work with Immutable.js.
The npm package react-immutable-proptypes receives a total of 250,389 weekly downloads. As such, react-immutable-proptypes popularity was classified as popular.
We found that react-immutable-proptypes demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Product
We're excited to announce that Socket now supports the Java programming language.
Security News
Socket detected a malicious Python package impersonating a popular browser cookie library to steal passwords, screenshots, webcam images, and Discord tokens.
Security News
Deno 2.0 is now available with enhanced package management, full Node.js and npm compatibility, improved performance, and support for major JavaScript frameworks.