1 | 'use strict';
|
2 |
|
3 | Object.defineProperty(exports, '__esModule', { value: true });
|
4 |
|
5 | function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
|
6 |
|
7 | var mobx = require('mobx');
|
8 | var React = require('react');
|
9 | var React__default = _interopDefault(React);
|
10 | var mobxReactLite = require('mobx-react-lite');
|
11 |
|
12 | var symbolId = 0;
|
13 |
|
14 | function createSymbol(name) {
|
15 | if (typeof Symbol === "function") {
|
16 | return Symbol(name);
|
17 | }
|
18 |
|
19 | var symbol = "__$mobx-react " + name + " (" + symbolId + ")";
|
20 | symbolId++;
|
21 | return symbol;
|
22 | }
|
23 |
|
24 | var createdSymbols = {};
|
25 | function newSymbol(name) {
|
26 | if (!createdSymbols[name]) {
|
27 | createdSymbols[name] = createSymbol(name);
|
28 | }
|
29 |
|
30 | return createdSymbols[name];
|
31 | }
|
32 | function shallowEqual(objA, objB) {
|
33 |
|
34 | if (is(objA, objB)) return true;
|
35 |
|
36 | if (typeof objA !== "object" || objA === null || typeof objB !== "object" || objB === null) {
|
37 | return false;
|
38 | }
|
39 |
|
40 | var keysA = Object.keys(objA);
|
41 | var keysB = Object.keys(objB);
|
42 | if (keysA.length !== keysB.length) return false;
|
43 |
|
44 | for (var i = 0; i < keysA.length; i++) {
|
45 | if (!Object.hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
|
46 | return false;
|
47 | }
|
48 | }
|
49 |
|
50 | return true;
|
51 | }
|
52 |
|
53 | function is(x, y) {
|
54 |
|
55 | if (x === y) {
|
56 | return x !== 0 || 1 / x === 1 / y;
|
57 | } else {
|
58 | return x !== x && y !== y;
|
59 | }
|
60 | }
|
61 |
|
62 |
|
63 | var hoistBlackList = {
|
64 | $$typeof: 1,
|
65 | render: 1,
|
66 | compare: 1,
|
67 | type: 1,
|
68 | childContextTypes: 1,
|
69 | contextType: 1,
|
70 | contextTypes: 1,
|
71 | defaultProps: 1,
|
72 | getDefaultProps: 1,
|
73 | getDerivedStateFromError: 1,
|
74 | getDerivedStateFromProps: 1,
|
75 | mixins: 1,
|
76 | propTypes: 1
|
77 | };
|
78 | function copyStaticProperties(base, target) {
|
79 | var protoProps = Object.getOwnPropertyNames(Object.getPrototypeOf(base));
|
80 | Object.getOwnPropertyNames(base).forEach(function (key) {
|
81 | if (!hoistBlackList[key] && protoProps.indexOf(key) === -1) {
|
82 | Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(base, key));
|
83 | }
|
84 | });
|
85 | }
|
86 |
|
87 |
|
88 |
|
89 |
|
90 |
|
91 |
|
92 |
|
93 | function setHiddenProp(target, prop, value) {
|
94 | if (!Object.hasOwnProperty.call(target, prop)) {
|
95 | Object.defineProperty(target, prop, {
|
96 | enumerable: false,
|
97 | configurable: true,
|
98 | writable: true,
|
99 | value: value
|
100 | });
|
101 | } else {
|
102 | target[prop] = value;
|
103 | }
|
104 | }
|
105 |
|
106 |
|
107 |
|
108 |
|
109 |
|
110 | var mobxMixins =
|
111 |
|
112 | newSymbol("patchMixins");
|
113 | var mobxPatchedDefinition =
|
114 |
|
115 | newSymbol("patchedDefinition");
|
116 |
|
117 | function getMixins(target, methodName) {
|
118 | var mixins = target[mobxMixins] = target[mobxMixins] || {};
|
119 | var methodMixins = mixins[methodName] = mixins[methodName] || {};
|
120 | methodMixins.locks = methodMixins.locks || 0;
|
121 | methodMixins.methods = methodMixins.methods || [];
|
122 | return methodMixins;
|
123 | }
|
124 |
|
125 | function wrapper(realMethod, mixins) {
|
126 | var _this = this;
|
127 |
|
128 | for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
|
129 | args[_key - 2] = arguments[_key];
|
130 | }
|
131 |
|
132 |
|
133 | mixins.locks++;
|
134 |
|
135 | try {
|
136 | var retVal;
|
137 |
|
138 | if (realMethod !== undefined && realMethod !== null) {
|
139 | retVal = realMethod.apply(this, args);
|
140 | }
|
141 |
|
142 | return retVal;
|
143 | } finally {
|
144 | mixins.locks--;
|
145 |
|
146 | if (mixins.locks === 0) {
|
147 | mixins.methods.forEach(function (mx) {
|
148 | mx.apply(_this, args);
|
149 | });
|
150 | }
|
151 | }
|
152 | }
|
153 |
|
154 | function wrapFunction(realMethod, mixins) {
|
155 | var fn = function fn() {
|
156 | for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
|
157 | args[_key2] = arguments[_key2];
|
158 | }
|
159 |
|
160 | wrapper.call.apply(wrapper, [this, realMethod, mixins].concat(args));
|
161 | };
|
162 |
|
163 | return fn;
|
164 | }
|
165 |
|
166 | function patch(target, methodName, mixinMethod) {
|
167 | var mixins = getMixins(target, methodName);
|
168 |
|
169 | if (mixins.methods.indexOf(mixinMethod) < 0) {
|
170 | mixins.methods.push(mixinMethod);
|
171 | }
|
172 |
|
173 | var oldDefinition = Object.getOwnPropertyDescriptor(target, methodName);
|
174 |
|
175 | if (oldDefinition && oldDefinition[mobxPatchedDefinition]) {
|
176 |
|
177 | return;
|
178 | }
|
179 |
|
180 | var originalMethod = target[methodName];
|
181 | var newDefinition = createDefinition(target, methodName, oldDefinition ? oldDefinition.enumerable : undefined, mixins, originalMethod);
|
182 | Object.defineProperty(target, methodName, newDefinition);
|
183 | }
|
184 |
|
185 | function createDefinition(target, methodName, enumerable, mixins, originalMethod) {
|
186 | var _ref;
|
187 |
|
188 | var wrappedFunc = wrapFunction(originalMethod, mixins);
|
189 | return _ref = {}, _ref[mobxPatchedDefinition] = true, _ref.get = function get() {
|
190 | return wrappedFunc;
|
191 | }, _ref.set = function set(value) {
|
192 | if (this === target) {
|
193 | wrappedFunc = wrapFunction(value, mixins);
|
194 | } else {
|
195 |
|
196 |
|
197 |
|
198 |
|
199 | var newDefinition = createDefinition(this, methodName, enumerable, mixins, value);
|
200 | Object.defineProperty(this, methodName, newDefinition);
|
201 | }
|
202 | }, _ref.configurable = true, _ref.enumerable = enumerable, _ref;
|
203 | }
|
204 |
|
205 | var mobxAdminProperty = mobx.$mobx || "$mobx";
|
206 | var mobxObserverProperty =
|
207 |
|
208 | newSymbol("isMobXReactObserver");
|
209 | var mobxIsUnmounted =
|
210 |
|
211 | newSymbol("isUnmounted");
|
212 | var skipRenderKey =
|
213 |
|
214 | newSymbol("skipRender");
|
215 | var isForcingUpdateKey =
|
216 |
|
217 | newSymbol("isForcingUpdate");
|
218 | function makeClassComponentObserver(componentClass) {
|
219 | var target = componentClass.prototype;
|
220 |
|
221 | if (componentClass[mobxObserverProperty]) {
|
222 | var displayName = getDisplayName(target);
|
223 | console.warn("The provided component class (" + displayName + ") \n has already been declared as an observer component.");
|
224 | } else {
|
225 | componentClass[mobxObserverProperty] = true;
|
226 | }
|
227 |
|
228 | if (target.componentWillReact) throw new Error("The componentWillReact life-cycle event is no longer supported");
|
229 |
|
230 | if (componentClass["__proto__"] !== React.PureComponent) {
|
231 | if (!target.shouldComponentUpdate) target.shouldComponentUpdate = observerSCU;else if (target.shouldComponentUpdate !== observerSCU)
|
232 | throw new Error("It is not allowed to use shouldComponentUpdate in observer based components.");
|
233 | }
|
234 |
|
235 |
|
236 |
|
237 |
|
238 |
|
239 | makeObservableProp(target, "props");
|
240 | makeObservableProp(target, "state");
|
241 | var baseRender = target.render;
|
242 |
|
243 | target.render = function () {
|
244 | return makeComponentReactive.call(this, baseRender);
|
245 | };
|
246 |
|
247 | patch(target, "componentWillUnmount", function () {
|
248 | var _this$render$mobxAdmi;
|
249 |
|
250 | if (mobxReactLite.isUsingStaticRendering() === true) return;
|
251 | (_this$render$mobxAdmi = this.render[mobxAdminProperty]) === null || _this$render$mobxAdmi === void 0 ? void 0 : _this$render$mobxAdmi.dispose();
|
252 | this[mobxIsUnmounted] = true;
|
253 |
|
254 | if (!this.render[mobxAdminProperty]) {
|
255 |
|
256 | var _displayName = getDisplayName(this);
|
257 |
|
258 | console.warn("The reactive render of an observer class component (" + _displayName + ") \n was overriden after MobX attached. This may result in a memory leak if the \n overriden reactive render was not properly disposed.");
|
259 | }
|
260 | });
|
261 | return componentClass;
|
262 | }
|
263 |
|
264 | function getDisplayName(comp) {
|
265 | return comp.displayName || comp.name || comp.constructor && (comp.constructor.displayName || comp.constructor.name) || "<component>";
|
266 | }
|
267 |
|
268 | function makeComponentReactive(render) {
|
269 | var _this = this;
|
270 |
|
271 | if (mobxReactLite.isUsingStaticRendering() === true) return render.call(this);
|
272 | |
273 |
|
274 |
|
275 |
|
276 |
|
277 | setHiddenProp(this, skipRenderKey, false);
|
278 | |
279 |
|
280 |
|
281 |
|
282 |
|
283 | setHiddenProp(this, isForcingUpdateKey, false);
|
284 | var initialName = getDisplayName(this);
|
285 | var baseRender = render.bind(this);
|
286 | var isRenderingPending = false;
|
287 | var reaction = new mobx.Reaction(initialName + ".render()", function () {
|
288 | if (!isRenderingPending) {
|
289 |
|
290 |
|
291 |
|
292 | isRenderingPending = true;
|
293 |
|
294 | if (_this[mobxIsUnmounted] !== true) {
|
295 | var hasError = true;
|
296 |
|
297 | try {
|
298 | setHiddenProp(_this, isForcingUpdateKey, true);
|
299 | if (!_this[skipRenderKey]) React.Component.prototype.forceUpdate.call(_this);
|
300 | hasError = false;
|
301 | } finally {
|
302 | setHiddenProp(_this, isForcingUpdateKey, false);
|
303 | if (hasError) reaction.dispose();
|
304 | }
|
305 | }
|
306 | }
|
307 | });
|
308 | reaction["reactComponent"] = this;
|
309 | reactiveRender[mobxAdminProperty] = reaction;
|
310 | this.render = reactiveRender;
|
311 |
|
312 | function reactiveRender() {
|
313 | isRenderingPending = false;
|
314 | var exception = undefined;
|
315 | var rendering = undefined;
|
316 | reaction.track(function () {
|
317 | try {
|
318 | rendering = mobx._allowStateChanges(false, baseRender);
|
319 | } catch (e) {
|
320 | exception = e;
|
321 | }
|
322 | });
|
323 |
|
324 | if (exception) {
|
325 | throw exception;
|
326 | }
|
327 |
|
328 | return rendering;
|
329 | }
|
330 |
|
331 | return reactiveRender.call(this);
|
332 | }
|
333 |
|
334 | function observerSCU(nextProps, nextState) {
|
335 | if (mobxReactLite.isUsingStaticRendering()) {
|
336 | console.warn("[mobx-react] It seems that a re-rendering of a React component is triggered while in static (server-side) mode. Please make sure components are rendered only once server-side.");
|
337 | }
|
338 |
|
339 |
|
340 | if (this.state !== nextState) {
|
341 | return true;
|
342 | }
|
343 |
|
344 |
|
345 |
|
346 |
|
347 |
|
348 | return !shallowEqual(this.props, nextProps);
|
349 | }
|
350 |
|
351 | function makeObservableProp(target, propName) {
|
352 | var valueHolderKey = newSymbol("reactProp_" + propName + "_valueHolder");
|
353 | var atomHolderKey = newSymbol("reactProp_" + propName + "_atomHolder");
|
354 |
|
355 | function getAtom() {
|
356 | if (!this[atomHolderKey]) {
|
357 | setHiddenProp(this, atomHolderKey, mobx.createAtom("reactive " + propName));
|
358 | }
|
359 |
|
360 | return this[atomHolderKey];
|
361 | }
|
362 |
|
363 | Object.defineProperty(target, propName, {
|
364 | configurable: true,
|
365 | enumerable: true,
|
366 | get: function get() {
|
367 | var prevReadState = false;
|
368 |
|
369 | if (mobx._allowStateReadsStart && mobx._allowStateReadsEnd) {
|
370 | prevReadState = mobx._allowStateReadsStart(true);
|
371 | }
|
372 |
|
373 | getAtom.call(this).reportObserved();
|
374 |
|
375 | if (mobx._allowStateReadsStart && mobx._allowStateReadsEnd) {
|
376 | mobx._allowStateReadsEnd(prevReadState);
|
377 | }
|
378 |
|
379 | return this[valueHolderKey];
|
380 | },
|
381 | set: function set(v) {
|
382 | if (!this[isForcingUpdateKey] && !shallowEqual(this[valueHolderKey], v)) {
|
383 | setHiddenProp(this, valueHolderKey, v);
|
384 | setHiddenProp(this, skipRenderKey, true);
|
385 | getAtom.call(this).reportChanged();
|
386 | setHiddenProp(this, skipRenderKey, false);
|
387 | } else {
|
388 | setHiddenProp(this, valueHolderKey, v);
|
389 | }
|
390 | }
|
391 | });
|
392 | }
|
393 |
|
394 | var hasSymbol = typeof Symbol === "function" && Symbol.for;
|
395 |
|
396 | var ReactForwardRefSymbol = hasSymbol ?
|
397 |
|
398 | Symbol.for("react.forward_ref") : typeof React.forwardRef === "function" &&
|
399 |
|
400 | React.forwardRef(function (props) {
|
401 | return null;
|
402 | })["$$typeof"];
|
403 | var ReactMemoSymbol = hasSymbol ?
|
404 |
|
405 | Symbol.for("react.memo") : typeof React.memo === "function" &&
|
406 |
|
407 | React.memo(function (props) {
|
408 | return null;
|
409 | })["$$typeof"];
|
410 |
|
411 |
|
412 |
|
413 |
|
414 | function observer(component) {
|
415 | if (component["isMobxInjector"] === true) {
|
416 | console.warn("Mobx observer: You are trying to use 'observer' on a component that already has 'inject'. Please apply 'observer' before applying 'inject'");
|
417 | }
|
418 |
|
419 | if (ReactMemoSymbol && component["$$typeof"] === ReactMemoSymbol) {
|
420 | throw new Error("Mobx observer: You are trying to use 'observer' on a function component wrapped in either another observer or 'React.memo'. The observer already applies 'React.memo' for you.");
|
421 | }
|
422 |
|
423 |
|
424 |
|
425 |
|
426 | if (ReactForwardRefSymbol && component["$$typeof"] === ReactForwardRefSymbol) {
|
427 | var baseRender = component["render"];
|
428 | if (typeof baseRender !== "function") throw new Error("render property of ForwardRef was not a function");
|
429 | return React.forwardRef(function ObserverForwardRef() {
|
430 | var args = arguments;
|
431 | return React.createElement(mobxReactLite.Observer, null, function () {
|
432 | return baseRender.apply(undefined, args);
|
433 | });
|
434 | });
|
435 | }
|
436 |
|
437 |
|
438 | if (typeof component === "function" && (!component.prototype || !component.prototype.render) && !component["isReactClass"] && !Object.prototype.isPrototypeOf.call(React.Component, component)) {
|
439 | return mobxReactLite.observer(component);
|
440 | }
|
441 |
|
442 | return makeClassComponentObserver(component);
|
443 | }
|
444 |
|
445 | function _extends() {
|
446 | _extends = Object.assign || function (target) {
|
447 | for (var i = 1; i < arguments.length; i++) {
|
448 | var source = arguments[i];
|
449 |
|
450 | for (var key in source) {
|
451 | if (Object.prototype.hasOwnProperty.call(source, key)) {
|
452 | target[key] = source[key];
|
453 | }
|
454 | }
|
455 | }
|
456 |
|
457 | return target;
|
458 | };
|
459 |
|
460 | return _extends.apply(this, arguments);
|
461 | }
|
462 |
|
463 | function _objectWithoutPropertiesLoose(source, excluded) {
|
464 | if (source == null) return {};
|
465 | var target = {};
|
466 | var sourceKeys = Object.keys(source);
|
467 | var key, i;
|
468 |
|
469 | for (i = 0; i < sourceKeys.length; i++) {
|
470 | key = sourceKeys[i];
|
471 | if (excluded.indexOf(key) >= 0) continue;
|
472 | target[key] = source[key];
|
473 | }
|
474 |
|
475 | return target;
|
476 | }
|
477 |
|
478 | var MobXProviderContext =
|
479 |
|
480 | React__default.createContext({});
|
481 | function Provider(props) {
|
482 | var children = props.children,
|
483 | stores = _objectWithoutPropertiesLoose(props, ["children"]);
|
484 |
|
485 | var parentValue = React__default.useContext(MobXProviderContext);
|
486 | var mutableProviderRef = React__default.useRef(_extends({}, parentValue, stores));
|
487 | var value = mutableProviderRef.current;
|
488 |
|
489 | {
|
490 | var newValue = _extends({}, value, stores);
|
491 |
|
492 |
|
493 | if (!shallowEqual(value, newValue)) {
|
494 | throw new Error("MobX Provider: The set of provided stores has changed. See: https://github.com/mobxjs/mobx-react#the-set-of-provided-stores-has-changed-error.");
|
495 | }
|
496 | }
|
497 |
|
498 | return React__default.createElement(MobXProviderContext.Provider, {
|
499 | value: value
|
500 | }, children);
|
501 | }
|
502 | Provider.displayName = "MobXProvider";
|
503 |
|
504 |
|
505 |
|
506 |
|
507 |
|
508 | function createStoreInjector(grabStoresFn, component, injectNames, makeReactive) {
|
509 |
|
510 | var Injector = React__default.forwardRef(function (props, ref) {
|
511 | var newProps = _extends({}, props);
|
512 |
|
513 | var context = React__default.useContext(MobXProviderContext);
|
514 | Object.assign(newProps, grabStoresFn(context || {}, newProps) || {});
|
515 |
|
516 | if (ref) {
|
517 | newProps.ref = ref;
|
518 | }
|
519 |
|
520 | return React__default.createElement(component, newProps);
|
521 | });
|
522 | if (makeReactive) Injector = observer(Injector);
|
523 | Injector["isMobxInjector"] = true;
|
524 |
|
525 |
|
526 | copyStaticProperties(component, Injector);
|
527 | Injector["wrappedComponent"] = component;
|
528 | Injector.displayName = getInjectName(component, injectNames);
|
529 | return Injector;
|
530 | }
|
531 |
|
532 | function getInjectName(component, injectNames) {
|
533 | var displayName;
|
534 | var componentName = component.displayName || component.name || component.constructor && component.constructor.name || "Component";
|
535 | if (injectNames) displayName = "inject-with-" + injectNames + "(" + componentName + ")";else displayName = "inject(" + componentName + ")";
|
536 | return displayName;
|
537 | }
|
538 |
|
539 | function grabStoresByName(storeNames) {
|
540 | return function (baseStores, nextProps) {
|
541 | storeNames.forEach(function (storeName) {
|
542 | if (storeName in nextProps
|
543 | ) return;
|
544 | if (!(storeName in baseStores)) throw new Error("MobX injector: Store '" + storeName + "' is not available! Make sure it is provided by some Provider");
|
545 | nextProps[storeName] = baseStores[storeName];
|
546 | });
|
547 | return nextProps;
|
548 | };
|
549 | }
|
550 |
|
551 |
|
552 |
|
553 |
|
554 |
|
555 |
|
556 |
|
557 |
|
558 | function inject() {
|
559 | for (var _len = arguments.length, storeNames = new Array(_len), _key = 0; _key < _len; _key++) {
|
560 | storeNames[_key] = arguments[_key];
|
561 | }
|
562 |
|
563 | if (typeof arguments[0] === "function") {
|
564 | var grabStoresFn = arguments[0];
|
565 | return function (componentClass) {
|
566 | return createStoreInjector(grabStoresFn, componentClass, grabStoresFn.name, true);
|
567 | };
|
568 | } else {
|
569 | return function (componentClass) {
|
570 | return createStoreInjector(grabStoresByName(storeNames), componentClass, storeNames.join("-"), false);
|
571 | };
|
572 | }
|
573 | }
|
574 |
|
575 | var protoStoreKey =
|
576 |
|
577 | newSymbol("disposeOnUnmountProto");
|
578 | var instStoreKey =
|
579 |
|
580 | newSymbol("disposeOnUnmountInst");
|
581 |
|
582 | function runDisposersOnWillUnmount() {
|
583 | var _this = this;
|
584 | [].concat(this[protoStoreKey] || [], this[instStoreKey] || []).forEach(function (propKeyOrFunction) {
|
585 | var prop = typeof propKeyOrFunction === "string" ? _this[propKeyOrFunction] : propKeyOrFunction;
|
586 |
|
587 | if (prop !== undefined && prop !== null) {
|
588 | if (Array.isArray(prop)) prop.map(function (f) {
|
589 | return f();
|
590 | });else prop();
|
591 | }
|
592 | });
|
593 | }
|
594 |
|
595 | function disposeOnUnmount(target, propertyKeyOrFunction) {
|
596 | if (Array.isArray(propertyKeyOrFunction)) {
|
597 | return propertyKeyOrFunction.map(function (fn) {
|
598 | return disposeOnUnmount(target, fn);
|
599 | });
|
600 | }
|
601 |
|
602 | var c = Object.getPrototypeOf(target).constructor;
|
603 | var c2 = Object.getPrototypeOf(target.constructor);
|
604 |
|
605 | var c3 = Object.getPrototypeOf(Object.getPrototypeOf(target));
|
606 |
|
607 | if (!(c === React__default.Component || c === React__default.PureComponent || c2 === React__default.Component || c2 === React__default.PureComponent || c3 === React__default.Component || c3 === React__default.PureComponent)) {
|
608 | throw new Error("[mobx-react] disposeOnUnmount only supports direct subclasses of React.Component or React.PureComponent.");
|
609 | }
|
610 |
|
611 | if (typeof propertyKeyOrFunction !== "string" && typeof propertyKeyOrFunction !== "function" && !Array.isArray(propertyKeyOrFunction)) {
|
612 | throw new Error("[mobx-react] disposeOnUnmount only works if the parameter is either a property key or a function.");
|
613 | }
|
614 |
|
615 |
|
616 | var isDecorator = typeof propertyKeyOrFunction === "string";
|
617 |
|
618 | var componentWasAlreadyModified = !!target[protoStoreKey] || !!target[instStoreKey];
|
619 | var store = isDecorator ?
|
620 | target[protoStoreKey] || (target[protoStoreKey] = []) :
|
621 | target[instStoreKey] || (target[instStoreKey] = []);
|
622 | store.push(propertyKeyOrFunction);
|
623 |
|
624 | if (!componentWasAlreadyModified) {
|
625 | patch(target, "componentWillUnmount", runDisposersOnWillUnmount);
|
626 | }
|
627 |
|
628 |
|
629 | if (typeof propertyKeyOrFunction !== "string") {
|
630 | return propertyKeyOrFunction;
|
631 | }
|
632 | }
|
633 |
|
634 | function createChainableTypeChecker(validator) {
|
635 | function checkType(isRequired, props, propName, componentName, location, propFullName) {
|
636 | for (var _len = arguments.length, rest = new Array(_len > 6 ? _len - 6 : 0), _key = 6; _key < _len; _key++) {
|
637 | rest[_key - 6] = arguments[_key];
|
638 | }
|
639 |
|
640 | return mobx.untracked(function () {
|
641 | componentName = componentName || "<<anonymous>>";
|
642 | propFullName = propFullName || propName;
|
643 |
|
644 | if (props[propName] == null) {
|
645 | if (isRequired) {
|
646 | var actual = props[propName] === null ? "null" : "undefined";
|
647 | return new Error("The " + location + " `" + propFullName + "` is marked as required " + "in `" + componentName + "`, but its value is `" + actual + "`.");
|
648 | }
|
649 |
|
650 | return null;
|
651 | } else {
|
652 |
|
653 | return validator.apply(void 0, [props, propName, componentName, location, propFullName].concat(rest));
|
654 | }
|
655 | });
|
656 | }
|
657 |
|
658 | var chainedCheckType = checkType.bind(null, false);
|
659 |
|
660 | chainedCheckType.isRequired = checkType.bind(null, true);
|
661 | return chainedCheckType;
|
662 | }
|
663 |
|
664 |
|
665 | function isSymbol(propType, propValue) {
|
666 |
|
667 | if (propType === "symbol") {
|
668 | return true;
|
669 | }
|
670 |
|
671 |
|
672 | if (propValue["@@toStringTag"] === "Symbol") {
|
673 | return true;
|
674 | }
|
675 |
|
676 |
|
677 | if (typeof Symbol === "function" && propValue instanceof Symbol) {
|
678 | return true;
|
679 | }
|
680 |
|
681 | return false;
|
682 | }
|
683 |
|
684 |
|
685 | function getPropType(propValue) {
|
686 | var propType = typeof propValue;
|
687 |
|
688 | if (Array.isArray(propValue)) {
|
689 | return "array";
|
690 | }
|
691 |
|
692 | if (propValue instanceof RegExp) {
|
693 |
|
694 |
|
695 |
|
696 | return "object";
|
697 | }
|
698 |
|
699 | if (isSymbol(propType, propValue)) {
|
700 | return "symbol";
|
701 | }
|
702 |
|
703 | return propType;
|
704 | }
|
705 |
|
706 |
|
707 |
|
708 | function getPreciseType(propValue) {
|
709 | var propType = getPropType(propValue);
|
710 |
|
711 | if (propType === "object") {
|
712 | if (propValue instanceof Date) {
|
713 | return "date";
|
714 | } else if (propValue instanceof RegExp) {
|
715 | return "regexp";
|
716 | }
|
717 | }
|
718 |
|
719 | return propType;
|
720 | }
|
721 |
|
722 | function createObservableTypeCheckerCreator(allowNativeType, mobxType) {
|
723 | return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
|
724 | return mobx.untracked(function () {
|
725 | if (allowNativeType) {
|
726 | if (getPropType(props[propName]) === mobxType.toLowerCase()) return null;
|
727 | }
|
728 |
|
729 | var mobxChecker;
|
730 |
|
731 | switch (mobxType) {
|
732 | case "Array":
|
733 | mobxChecker = mobx.isObservableArray;
|
734 | break;
|
735 |
|
736 | case "Object":
|
737 | mobxChecker = mobx.isObservableObject;
|
738 | break;
|
739 |
|
740 | case "Map":
|
741 | mobxChecker = mobx.isObservableMap;
|
742 | break;
|
743 |
|
744 | default:
|
745 | throw new Error("Unexpected mobxType: " + mobxType);
|
746 | }
|
747 |
|
748 | var propValue = props[propName];
|
749 |
|
750 | if (!mobxChecker(propValue)) {
|
751 | var preciseType = getPreciseType(propValue);
|
752 | var nativeTypeExpectationMessage = allowNativeType ? " or javascript `" + mobxType.toLowerCase() + "`" : "";
|
753 | return new Error("Invalid prop `" + propFullName + "` of type `" + preciseType + "` supplied to" + " `" + componentName + "`, expected `mobx.Observable" + mobxType + "`" + nativeTypeExpectationMessage + ".");
|
754 | }
|
755 |
|
756 | return null;
|
757 | });
|
758 | });
|
759 | }
|
760 |
|
761 | function createObservableArrayOfTypeChecker(allowNativeType, typeChecker) {
|
762 | return createChainableTypeChecker(function (props, propName, componentName, location, propFullName) {
|
763 | for (var _len2 = arguments.length, rest = new Array(_len2 > 5 ? _len2 - 5 : 0), _key2 = 5; _key2 < _len2; _key2++) {
|
764 | rest[_key2 - 5] = arguments[_key2];
|
765 | }
|
766 |
|
767 | return mobx.untracked(function () {
|
768 | if (typeof typeChecker !== "function") {
|
769 | return new Error("Property `" + propFullName + "` of component `" + componentName + "` has " + "invalid PropType notation.");
|
770 | } else {
|
771 | var error = createObservableTypeCheckerCreator(allowNativeType, "Array")(props, propName, componentName, location, propFullName);
|
772 | if (error instanceof Error) return error;
|
773 | var propValue = props[propName];
|
774 |
|
775 | for (var i = 0; i < propValue.length; i++) {
|
776 | error = typeChecker.apply(void 0, [propValue, i, componentName, location, propFullName + "[" + i + "]"].concat(rest));
|
777 | if (error instanceof Error) return error;
|
778 | }
|
779 |
|
780 | return null;
|
781 | }
|
782 | });
|
783 | });
|
784 | }
|
785 |
|
786 | var observableArray =
|
787 |
|
788 | createObservableTypeCheckerCreator(false, "Array");
|
789 | var observableArrayOf =
|
790 |
|
791 | createObservableArrayOfTypeChecker.bind(null, false);
|
792 | var observableMap =
|
793 |
|
794 | createObservableTypeCheckerCreator(false, "Map");
|
795 | var observableObject =
|
796 |
|
797 | createObservableTypeCheckerCreator(false, "Object");
|
798 | var arrayOrObservableArray =
|
799 |
|
800 | createObservableTypeCheckerCreator(true, "Array");
|
801 | var arrayOrObservableArrayOf =
|
802 |
|
803 | createObservableArrayOfTypeChecker.bind(null, true);
|
804 | var objectOrObservableObject =
|
805 |
|
806 | createObservableTypeCheckerCreator(true, "Object");
|
807 | var PropTypes = {
|
808 | observableArray: observableArray,
|
809 | observableArrayOf: observableArrayOf,
|
810 | observableMap: observableMap,
|
811 | observableObject: observableObject,
|
812 | arrayOrObservableArray: arrayOrObservableArray,
|
813 | arrayOrObservableArrayOf: arrayOrObservableArrayOf,
|
814 | objectOrObservableObject: objectOrObservableObject
|
815 | };
|
816 |
|
817 | if (!React.Component) throw new Error("mobx-react requires React to be available");
|
818 | if (!mobx.observable) throw new Error("mobx-react requires mobx to be available");
|
819 |
|
820 | Object.defineProperty(exports, 'Observer', {
|
821 | enumerable: true,
|
822 | get: function () {
|
823 | return mobxReactLite.Observer;
|
824 | }
|
825 | });
|
826 | Object.defineProperty(exports, 'isUsingStaticRendering', {
|
827 | enumerable: true,
|
828 | get: function () {
|
829 | return mobxReactLite.isUsingStaticRendering;
|
830 | }
|
831 | });
|
832 | Object.defineProperty(exports, 'observerBatching', {
|
833 | enumerable: true,
|
834 | get: function () {
|
835 | return mobxReactLite.observerBatching;
|
836 | }
|
837 | });
|
838 | Object.defineProperty(exports, 'useAsObservableSource', {
|
839 | enumerable: true,
|
840 | get: function () {
|
841 | return mobxReactLite.useAsObservableSource;
|
842 | }
|
843 | });
|
844 | Object.defineProperty(exports, 'useLocalStore', {
|
845 | enumerable: true,
|
846 | get: function () {
|
847 | return mobxReactLite.useLocalStore;
|
848 | }
|
849 | });
|
850 | Object.defineProperty(exports, 'useObserver', {
|
851 | enumerable: true,
|
852 | get: function () {
|
853 | return mobxReactLite.useObserver;
|
854 | }
|
855 | });
|
856 | Object.defineProperty(exports, 'useStaticRendering', {
|
857 | enumerable: true,
|
858 | get: function () {
|
859 | return mobxReactLite.useStaticRendering;
|
860 | }
|
861 | });
|
862 | exports.MobXProviderContext = MobXProviderContext;
|
863 | exports.PropTypes = PropTypes;
|
864 | exports.Provider = Provider;
|
865 | exports.disposeOnUnmount = disposeOnUnmount;
|
866 | exports.inject = inject;
|
867 | exports.observer = observer;
|
868 |
|