source: node_modules/react-immutable-proptypes/dist/ImmutablePropTypes.js

main
Last change on this file was d24f17c, checked in by Aleksandar Panovski <apano77@…>, 15 months ago

Initial commit
  • Property mode set to 100644
File size: 11.8 KB
Line 
1/**
2 * This is a straight rip-off of the React.js ReactPropTypes.js proptype validators,
3 * modified to make it possible to validate Immutable.js data.
4 * ImmutableTypes.listOf is patterned after React.PropTypes.arrayOf, but for Immutable.List
5 * ImmutableTypes.shape is based on React.PropTypes.shape, but for any Immutable.Iterable
6 */
7"use strict";
8
9var Immutable = require("immutable");
10
11var ANONYMOUS = "<<anonymous>>";
12
13var ImmutablePropTypes;
14
15if (process.env.NODE_ENV !== "production") {
16 ImmutablePropTypes = {
17 listOf: createListOfTypeChecker,
18 mapOf: createMapOfTypeChecker,
19 orderedMapOf: createOrderedMapOfTypeChecker,
20 setOf: createSetOfTypeChecker,
21 orderedSetOf: createOrderedSetOfTypeChecker,
22 stackOf: createStackOfTypeChecker,
23 iterableOf: createIterableOfTypeChecker,
24 recordOf: createRecordOfTypeChecker,
25 shape: createShapeChecker,
26 contains: createShapeChecker,
27 mapContains: createMapContainsChecker,
28 orderedMapContains: createOrderedMapContainsChecker,
29 // Primitive Types
30 list: createImmutableTypeChecker("List", Immutable.List.isList),
31 map: createImmutableTypeChecker("Map", Immutable.Map.isMap),
32 orderedMap: createImmutableTypeChecker("OrderedMap", Immutable.OrderedMap.isOrderedMap),
33 set: createImmutableTypeChecker("Set", Immutable.Set.isSet),
34 orderedSet: createImmutableTypeChecker("OrderedSet", Immutable.OrderedSet.isOrderedSet),
35 stack: createImmutableTypeChecker("Stack", Immutable.Stack.isStack),
36 seq: createImmutableTypeChecker("Seq", Immutable.Seq.isSeq),
37 record: createImmutableTypeChecker("Record", function (isRecord) {
38 return isRecord instanceof Immutable.Record;
39 }),
40 iterable: createImmutableTypeChecker("Iterable", Immutable.Iterable.isIterable)
41 };
42} else {
43 var productionTypeChecker = function productionTypeChecker() {
44 invariant(false, "ImmutablePropTypes type checking code is stripped in production.");
45 };
46 productionTypeChecker.isRequired = productionTypeChecker;
47 var getProductionTypeChecker = function getProductionTypeChecker() {
48 return productionTypeChecker;
49 };
50
51 ImmutablePropTypes = {
52 listOf: getProductionTypeChecker,
53 mapOf: getProductionTypeChecker,
54 orderedMapOf: getProductionTypeChecker,
55 setOf: getProductionTypeChecker,
56 orderedSetOf: getProductionTypeChecker,
57 stackOf: getProductionTypeChecker,
58 iterableOf: getProductionTypeChecker,
59 recordOf: getProductionTypeChecker,
60 shape: getProductionTypeChecker,
61 contains: getProductionTypeChecker,
62 mapContains: getProductionTypeChecker,
63 orderedMapContains: getProductionTypeChecker,
64 // Primitive Types
65 list: productionTypeChecker,
66 map: productionTypeChecker,
67 orderedMap: productionTypeChecker,
68 set: productionTypeChecker,
69 orderedSet: productionTypeChecker,
70 stack: productionTypeChecker,
71 seq: productionTypeChecker,
72 record: productionTypeChecker,
73 iterable: productionTypeChecker
74 };
75}
76
77ImmutablePropTypes.iterable.indexed = createIterableSubclassTypeChecker("Indexed", Immutable.Iterable.isIndexed);
78ImmutablePropTypes.iterable.keyed = createIterableSubclassTypeChecker("Keyed", Immutable.Iterable.isKeyed);
79
80function getPropType(propValue) {
81 var propType = typeof propValue;
82 if (Array.isArray(propValue)) {
83 return "array";
84 }
85 if (propValue instanceof RegExp) {
86 // Old webkits (at least until Android 4.0) return 'function' rather than
87 // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
88 // passes PropTypes.object.
89 return "object";
90 }
91 if (propValue instanceof Immutable.Iterable) {
92 return "Immutable." + propValue.toSource().split(" ")[0];
93 }
94 return propType;
95}
96
97function createChainableTypeChecker(validate) {
98 function checkType(isRequired, props, propName, componentName, location, propFullName) {
99 for (var _len = arguments.length, rest = Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
100 rest[_key - 6] = arguments[_key];
101 }
102
103 propFullName = propFullName || propName;
104 componentName = componentName || ANONYMOUS;
105 if (props[propName] == null) {
106 var locationName = location;
107 if (isRequired) {
108 return new Error("Required " + locationName + " `" + propFullName + "` was not specified in " + ("`" + componentName + "`."));
109 }
110 } else {
111 return validate.apply(undefined, [props, propName, componentName, location, propFullName].concat(rest));
112 }
113 }
114
115 var chainedCheckType = checkType.bind(null, false);
116 chainedCheckType.isRequired = checkType.bind(null, true);
117
118 return chainedCheckType;
119}
120
121function createImmutableTypeChecker(immutableClassName, immutableClassTypeValidator) {
122 function validate(props, propName, componentName, location, propFullName) {
123 var propValue = props[propName];
124 if (!immutableClassTypeValidator(propValue)) {
125 var propType = getPropType(propValue);
126 return new Error("Invalid " + location + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected `" + immutableClassName + "`."));
127 }
128 return null;
129 }
130 return createChainableTypeChecker(validate);
131}
132
133function createIterableSubclassTypeChecker(subclassName, validator) {
134 return createImmutableTypeChecker("Iterable." + subclassName, function (propValue) {
135 return Immutable.Iterable.isIterable(propValue) && validator(propValue);
136 });
137}
138
139function createIterableTypeChecker(typeChecker, immutableClassName, immutableClassTypeValidator) {
140
141 function validate(props, propName, componentName, location, propFullName) {
142 for (var _len = arguments.length, rest = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
143 rest[_key - 5] = arguments[_key];
144 }
145
146 var propValue = props[propName];
147 if (!immutableClassTypeValidator(propValue)) {
148 var locationName = location;
149 var propType = getPropType(propValue);
150 return new Error("Invalid " + locationName + " `" + propFullName + "` of type " + ("`" + propType + "` supplied to `" + componentName + "`, expected an Immutable.js " + immutableClassName + "."));
151 }
152
153 if (typeof typeChecker !== "function") {
154 return new Error("Invalid typeChecker supplied to `" + componentName + "` " + ("for propType `" + propFullName + "`, expected a function."));
155 }
156
157 var propValues = propValue.valueSeq().toArray();
158 for (var i = 0, len = propValues.length; i < len; i++) {
159 var error = typeChecker.apply(undefined, [propValues, i, componentName, location, "" + propFullName + "[" + i + "]"].concat(rest));
160 if (error instanceof Error) {
161 return error;
162 }
163 }
164 }
165 return createChainableTypeChecker(validate);
166}
167
168function createKeysTypeChecker(typeChecker) {
169
170 function validate(props, propName, componentName, location, propFullName) {
171 for (var _len = arguments.length, rest = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
172 rest[_key - 5] = arguments[_key];
173 }
174
175 var propValue = props[propName];
176 if (typeof typeChecker !== "function") {
177 return new Error("Invalid keysTypeChecker (optional second argument) supplied to `" + componentName + "` " + ("for propType `" + propFullName + "`, expected a function."));
178 }
179
180 var keys = propValue.keySeq().toArray();
181 for (var i = 0, len = keys.length; i < len; i++) {
182 var error = typeChecker.apply(undefined, [keys, i, componentName, location, "" + propFullName + " -> key(" + keys[i] + ")"].concat(rest));
183 if (error instanceof Error) {
184 return error;
185 }
186 }
187 }
188 return createChainableTypeChecker(validate);
189}
190
191function createListOfTypeChecker(typeChecker) {
192 return createIterableTypeChecker(typeChecker, "List", Immutable.List.isList);
193}
194
195function createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, immutableClassName, immutableClassTypeValidator) {
196 function validate() {
197 for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
198 args[_key] = arguments[_key];
199 }
200
201 return createIterableTypeChecker(valuesTypeChecker, immutableClassName, immutableClassTypeValidator).apply(undefined, args) || keysTypeChecker && createKeysTypeChecker(keysTypeChecker).apply(undefined, args);
202 }
203
204 return createChainableTypeChecker(validate);
205}
206
207function createMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
208 return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, "Map", Immutable.Map.isMap);
209}
210
211function createOrderedMapOfTypeChecker(valuesTypeChecker, keysTypeChecker) {
212 return createMapOfTypeCheckerFactory(valuesTypeChecker, keysTypeChecker, "OrderedMap", Immutable.OrderedMap.isOrderedMap);
213}
214
215function createSetOfTypeChecker(typeChecker) {
216 return createIterableTypeChecker(typeChecker, "Set", Immutable.Set.isSet);
217}
218
219function createOrderedSetOfTypeChecker(typeChecker) {
220 return createIterableTypeChecker(typeChecker, "OrderedSet", Immutable.OrderedSet.isOrderedSet);
221}
222
223function createStackOfTypeChecker(typeChecker) {
224 return createIterableTypeChecker(typeChecker, "Stack", Immutable.Stack.isStack);
225}
226
227function createIterableOfTypeChecker(typeChecker) {
228 return createIterableTypeChecker(typeChecker, "Iterable", Immutable.Iterable.isIterable);
229}
230
231function createRecordOfTypeChecker(recordKeys) {
232 function validate(props, propName, componentName, location, propFullName) {
233 for (var _len = arguments.length, rest = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
234 rest[_key - 5] = arguments[_key];
235 }
236
237 var propValue = props[propName];
238 if (!(propValue instanceof Immutable.Record)) {
239 var propType = getPropType(propValue);
240 var locationName = location;
241 return new Error("Invalid " + locationName + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected an Immutable.js Record."));
242 }
243 for (var key in recordKeys) {
244 var checker = recordKeys[key];
245 if (!checker) {
246 continue;
247 }
248 var mutablePropValue = propValue.toObject();
249 var error = checker.apply(undefined, [mutablePropValue, key, componentName, location, "" + propFullName + "." + key].concat(rest));
250 if (error) {
251 return error;
252 }
253 }
254 }
255 return createChainableTypeChecker(validate);
256}
257
258// there is some irony in the fact that shapeTypes is a standard hash and not an immutable collection
259function createShapeTypeChecker(shapeTypes) {
260 var immutableClassName = arguments[1] === undefined ? "Iterable" : arguments[1];
261 var immutableClassTypeValidator = arguments[2] === undefined ? Immutable.Iterable.isIterable : arguments[2];
262
263 function validate(props, propName, componentName, location, propFullName) {
264 for (var _len = arguments.length, rest = Array(_len > 5 ? _len - 5 : 0), _key = 5; _key < _len; _key++) {
265 rest[_key - 5] = arguments[_key];
266 }
267
268 var propValue = props[propName];
269 if (!immutableClassTypeValidator(propValue)) {
270 var propType = getPropType(propValue);
271 var locationName = location;
272 return new Error("Invalid " + locationName + " `" + propFullName + "` of type `" + propType + "` " + ("supplied to `" + componentName + "`, expected an Immutable.js " + immutableClassName + "."));
273 }
274 var mutablePropValue = propValue.toObject();
275 for (var key in shapeTypes) {
276 var checker = shapeTypes[key];
277 if (!checker) {
278 continue;
279 }
280 var error = checker.apply(undefined, [mutablePropValue, key, componentName, location, "" + propFullName + "." + key].concat(rest));
281 if (error) {
282 return error;
283 }
284 }
285 }
286 return createChainableTypeChecker(validate);
287}
288
289function createShapeChecker(shapeTypes) {
290 return createShapeTypeChecker(shapeTypes);
291}
292
293function createMapContainsChecker(shapeTypes) {
294 return createShapeTypeChecker(shapeTypes, "Map", Immutable.Map.isMap);
295}
296
297function createOrderedMapContainsChecker(shapeTypes) {
298 return createShapeTypeChecker(shapeTypes, "OrderedMap", Immutable.OrderedMap.isOrderedMap);
299}
300
301module.exports = ImmutablePropTypes;
Note: See TracBrowser for help on using the repository browser.