Renamed Descriptor -> Element
We've decided on a new naming convention for ReactDescriptor. It's now called ReactElement, which is a subset of the ReactNode union type.
Sebastian Markbage committed
Oct 7, 2014 at 13:41 UTC
8f1657bba618846b7a111a2caee855bf59145c5a
37 files changed
+396
-397
src/browser/ReactDOM.js
+8
-8
@@ -19,26 +19,26 @@
19
20
"use strict";
21
22
-var ReactDescriptor = require('ReactDescriptor');
23
-var ReactDescriptorValidator = require('ReactDescriptorValidator');
24
-var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
22
+var ReactElement = require('ReactElement');
23
+var ReactElementValidator = require('ReactElementValidator');
24
+var ReactLegacyElement = require('ReactLegacyElement');
25
26
var mapObject = require('mapObject');
27
28
/**
29
- * Create a factory that creates HTML tag descriptors.
29
+ * Create a factory that creates HTML tag elements.
30
*
31
* @param {string} tag Tag name (e.g. `div`).
32
* @private
33
*/
34
function createDOMFactory(tag) {
35
if (__DEV__) {
36
- return ReactLegacyDescriptor.markNonLegacyFactory(
37
- ReactDescriptorValidator.createFactory(tag)
36
+ return ReactLegacyElement.markNonLegacyFactory(
37
+ ReactElementValidator.createFactory(tag)
38
);
39
}
40
- return ReactLegacyDescriptor.markNonLegacyFactory(
41
- ReactDescriptor.createFactory(tag)
40
+ return ReactLegacyElement.markNonLegacyFactory(
41
+ ReactElement.createFactory(tag)
42
);
43
}
44
src/browser/ReactTextComponent.js
+2
-2
@@ -22,7 +22,7 @@
22
var DOMPropertyOperations = require('DOMPropertyOperations');
23
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
24
var ReactComponent = require('ReactComponent');
25
-var ReactDescriptor = require('ReactDescriptor');
25
+var ReactElement = require('ReactElement');
26
27
var escapeTextForBrowser = require('escapeTextForBrowser');
28
var mixInto = require('mixInto');
@@ -105,7 +105,7 @@ mixInto(ReactTextComponent, {
105
106
var ReactTextComponentFactory = function(text) {
107
// Bypass validation and configuration
108
- return new ReactDescriptor(ReactTextComponent, null, null, null, null, text);
108
+ return new ReactElement(ReactTextComponent, null, null, null, null, text);
109
};
110
111
ReactTextComponentFactory.type = ReactTextComponent;
src/browser/__tests__/ReactDOM-test.js
+4
-4
@@ -122,8 +122,8 @@ describe('ReactDOM', function() {
122
123
it('allow React.DOM factories to be called without warnings', function() {
124
spyOn(console, 'warn');
125
- var descriptor = React.DOM.div();
126
- expect(descriptor.type).toBe('div');
125
+ var element = React.DOM.div();
126
+ expect(element.type).toBe('div');
127
expect(console.warn.argsForCall.length).toBe(0);
128
});
129
@@ -139,8 +139,8 @@ describe('ReactDOM', function() {
139
140
it('warns but allow dom factories to be used in createElement', function() {
141
spyOn(console, 'warn');
142
- var descriptor = React.createElement(React.DOM.div);
143
- expect(descriptor.type).toBe('div');
142
+ var element = React.createElement(React.DOM.div);
143
+ expect(element.type).toBe('div');
144
expect(console.warn.argsForCall.length).toBe(1);
145
expect(console.warn.argsForCall[0][0]).toContain(
146
'Do not pass React.DOM.div'
src/browser/server/ReactServerRendering.js
+3
-3
@@ -18,7 +18,7 @@
18
*/
19
"use strict";
20
21
-var ReactDescriptor = require('ReactDescriptor');
21
+var ReactElement = require('ReactElement');
22
var ReactInstanceHandles = require('ReactInstanceHandles');
23
var ReactMarkupChecksum = require('ReactMarkupChecksum');
24
var ReactServerRenderingTransaction =
@@ -33,7 +33,7 @@ var invariant = require('invariant');
33
*/
34
function renderComponentToString(component) {
35
invariant(
36
- ReactDescriptor.isValidDescriptor(component),
36
+ ReactElement.isValidElement(component),
37
'renderComponentToString(): You must pass a valid ReactComponent.'
38
);
39
@@ -65,7 +65,7 @@ function renderComponentToString(component) {
65
*/
66
function renderComponentToStaticMarkup(component) {
67
invariant(
68
- ReactDescriptor.isValidDescriptor(component),
68
+ ReactElement.isValidElement(component),
69
'renderComponentToStaticMarkup(): You must pass a valid ReactComponent.'
70
);
71
src/browser/ui/React.js
+15
-15
@@ -29,13 +29,13 @@ var ReactComponent = require('ReactComponent');
29
var ReactCompositeComponent = require('ReactCompositeComponent');
30
var ReactContext = require('ReactContext');
31
var ReactCurrentOwner = require('ReactCurrentOwner');
32
-var ReactDescriptor = require('ReactDescriptor');
33
-var ReactDescriptorValidator = require('ReactDescriptorValidator');
32
+var ReactElement = require('ReactElement');
33
+var ReactElementValidator = require('ReactElementValidator');
34
var ReactDOM = require('ReactDOM');
35
var ReactDOMComponent = require('ReactDOMComponent');
36
var ReactDefaultInjection = require('ReactDefaultInjection');
37
var ReactInstanceHandles = require('ReactInstanceHandles');
38
-var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
38
+var ReactLegacyElement = require('ReactLegacyElement');
39
var ReactMount = require('ReactMount');
40
var ReactMultiChild = require('ReactMultiChild');
41
var ReactPerf = require('ReactPerf');
@@ -47,19 +47,19 @@ var onlyChild = require('onlyChild');
47
48
ReactDefaultInjection.inject();
49
50
-var createDescriptor = ReactDescriptor.createDescriptor;
51
-var createFactory = ReactDescriptor.createFactory;
50
+var createElement = ReactElement.createElement;
51
+var createFactory = ReactElement.createFactory;
52
53
if (__DEV__) {
54
- createDescriptor = ReactDescriptorValidator.createDescriptor;
55
- createFactory = ReactDescriptorValidator.createFactory;
54
+ createElement = ReactElementValidator.createElement;
55
+ createFactory = ReactElementValidator.createFactory;
56
}
57
58
-// TODO: Drop legacy descriptors once classes no longer export these factories
59
-createDescriptor = ReactLegacyDescriptor.wrapCreateDescriptor(
60
- createDescriptor
58
+// TODO: Drop legacy elements once classes no longer export these factories
59
+createElement = ReactLegacyElement.wrapCreateElement(
60
+ createElement
61
);
62
-createFactory = ReactLegacyDescriptor.wrapCreateFactory(
62
+createFactory = ReactLegacyElement.wrapCreateFactory(
63
createFactory
64
);
65
@@ -76,8 +76,8 @@ var React = {
76
EventPluginUtils.useTouchEvents = shouldUseTouch;
77
},
78
createClass: ReactCompositeComponent.createClass,
79
- createDescriptor: createDescriptor, // deprecated, will be removed next week
80
- createElement: createDescriptor,
79
+ createDescriptor: createElement, // deprecated, will be removed next week
80
+ createElement: createElement,
81
createFactory: createFactory,
82
constructAndRenderComponent: ReactMount.constructAndRenderComponent,
83
constructAndRenderComponentByID: ReactMount.constructAndRenderComponentByID,
@@ -90,8 +90,8 @@ var React = {
90
renderComponentToStaticMarkup:
91
ReactServerRendering.renderComponentToStaticMarkup,
92
unmountComponentAtNode: ReactMount.unmountComponentAtNode,
93
- isValidClass: ReactLegacyDescriptor.isValidFactory,
94
- isValidComponent: ReactDescriptor.isValidDescriptor,
93
+ isValidClass: ReactLegacyElement.isValidFactory,
94
+ isValidComponent: ReactElement.isValidElement,
95
withContext: ReactContext.withContext,
96
__internals: {
97
Component: ReactComponent,
src/browser/ui/ReactDOMComponent.js
+13
-13
@@ -260,22 +260,22 @@ ReactDOMComponent.Mixin = {
260
return '';
261
},
262
263
- receiveComponent: function(nextDescriptor, transaction) {
264
- if (nextDescriptor === this._descriptor &&
265
- nextDescriptor._owner != null) {
266
- // Since descriptors are immutable after the owner is rendered,
263
+ receiveComponent: function(nextElement, transaction) {
264
+ if (nextElement === this._currentElement &&
265
+ nextElement._owner != null) {
266
+ // Since elements are immutable after the owner is rendered,
267
// we can do a cheap identity compare here to determine if this is a
268
// superfluous reconcile. It's possible for state to be mutable but such
269
// change should trigger an update of the owner which would recreate
270
- // the descriptor. We explicitly check for the existence of an owner since
271
- // it's possible for a descriptor created outside a composite to be
270
+ // the element. We explicitly check for the existence of an owner since
271
+ // it's possible for a element created outside a composite to be
272
// deeply mutated and reused.
273
return;
274
}
275
276
ReactComponent.Mixin.receiveComponent.call(
277
this,
278
- nextDescriptor,
278
+ nextElement,
279
transaction
280
);
281
},
@@ -285,22 +285,22 @@ ReactDOMComponent.Mixin = {
285
* attached to the DOM. Reconciles the root DOM node, then recurses.
286
*
287
* @param {ReactReconcileTransaction} transaction
288
- * @param {ReactDescriptor} prevDescriptor
288
+ * @param {ReactElement} prevElement
289
* @internal
290
* @overridable
291
*/
292
updateComponent: ReactPerf.measure(
293
'ReactDOMComponent',
294
'updateComponent',
295
- function(transaction, prevDescriptor) {
296
- assertValidProps(this._descriptor.props);
295
+ function(transaction, prevElement) {
296
+ assertValidProps(this._currentElement.props);
297
ReactComponent.Mixin.updateComponent.call(
298
this,
299
transaction,
300
- prevDescriptor
300
+ prevElement
301
);
302
- this._updateDOMProperties(prevDescriptor.props, transaction);
303
- this._updateDOMChildren(prevDescriptor.props, transaction);
302
+ this._updateDOMProperties(prevElement.props, transaction);
303
+ this._updateDOMChildren(prevElement.props, transaction);
304
}
305
),
306
src/browser/ui/ReactMount.js
+18
-18
@@ -21,8 +21,8 @@
21
var DOMProperty = require('DOMProperty');
22
var ReactBrowserEventEmitter = require('ReactBrowserEventEmitter');
23
var ReactCurrentOwner = require('ReactCurrentOwner');
24
-var ReactDescriptor = require('ReactDescriptor');
25
-var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
24
+var ReactElement = require('ReactElement');
25
+var ReactLegacyElement = require('ReactLegacyElement');
26
var ReactInstanceHandles = require('ReactInstanceHandles');
27
var ReactPerf = require('ReactPerf');
28
@@ -33,8 +33,8 @@ var invariant = require('invariant');
33
var shouldUpdateReactComponent = require('shouldUpdateReactComponent');
34
var warning = require('warning');
35
36
-var createDescriptor = ReactLegacyDescriptor.wrapCreateDescriptor(
37
- ReactDescriptor.createDescriptor
36
+var createElement = ReactLegacyElement.wrapCreateElement(
37
+ ReactElement.createElement
38
);
39
40
var SEPARATOR = ReactInstanceHandles.SEPARATOR;
@@ -335,24 +335,24 @@ var ReactMount = {
335
* perform an update on it and only mutate the DOM as necessary to reflect the
336
* latest React component.
337
*
338
- * @param {ReactDescriptor} nextDescriptor Component descriptor to render.
338
+ * @param {ReactElement} nextElement Component element to render.
339
* @param {DOMElement} container DOM element to render into.
340
* @param {?function} callback function triggered on completion
341
* @return {ReactComponent} Component instance rendered in `container`.
342
*/
343
- renderComponent: function(nextDescriptor, container, callback) {
343
+ renderComponent: function(nextElement, container, callback) {
344
invariant(
345
- ReactDescriptor.isValidDescriptor(nextDescriptor),
346
- 'renderComponent(): Invalid component descriptor.%s',
345
+ ReactElement.isValidElement(nextElement),
346
+ 'renderComponent(): Invalid component element.%s',
347
(
348
- typeof nextDescriptor === 'string' ?
348
+ typeof nextElement === 'string' ?
349
' Instead of passing an element string, make sure to instantiate ' +
350
'it by passing it to React.createElement.' :
351
- ReactLegacyDescriptor.isValidFactory(nextDescriptor) ?
351
+ ReactLegacyElement.isValidFactory(nextElement) ?
352
' Instead of passing a component class, make sure to instantiate ' +
353
'it by passing it to React.createElement.' :
354
- // Check if it quacks like a descriptor
355
- typeof nextDescriptor.props !== "undefined" ?
354
+ // Check if it quacks like a element
355
+ typeof nextElement.props !== "undefined" ?
356
' This may be caused by unintentionally loading two independent ' +
357
'copies of React.' :
358
''
@@ -362,11 +362,11 @@ var ReactMount = {
362
var prevComponent = instancesByReactRootID[getReactRootID(container)];
363
364
if (prevComponent) {
365
- var prevDescriptor = prevComponent._descriptor;
366
- if (shouldUpdateReactComponent(prevDescriptor, nextDescriptor)) {
365
+ var prevElement = prevComponent._currentElement;
366
+ if (shouldUpdateReactComponent(prevElement, nextElement)) {
367
return ReactMount._updateRootComponent(
368
prevComponent,
369
- nextDescriptor,
369
+ nextElement,
370
container,
371
callback
372
);
@@ -382,7 +382,7 @@ var ReactMount = {
382
var shouldReuseMarkup = containerHasReactMarkup && !prevComponent;
383
384
var component = ReactMount._renderNewRootComponent(
385
- nextDescriptor,
385
+ nextElement,
386
container,
387
shouldReuseMarkup
388
);
@@ -400,8 +400,8 @@ var ReactMount = {
400
* @return {ReactComponent} Component instance rendered in `container`.
401
*/
402
constructAndRenderComponent: function(constructor, props, container) {
403
- var descriptor = createDescriptor(constructor, props);
404
- return ReactMount.renderComponent(descriptor, container);
403
+ var element = createElement(constructor, props);
404
+ return ReactMount.renderComponent(element, container);
405
},
406
407
/**
src/browser/ui/__tests__/ReactDOMComponent-test.js
+2
-2
@@ -318,8 +318,8 @@ describe('ReactDOMComponent', function() {
318
var ReactDOMComponent = require('ReactDOMComponent');
319
var ReactReconcileTransaction = require('ReactReconcileTransaction');
320
321
- var StubNativeComponent = function(descriptor) {
322
- ReactComponent.Mixin.construct.call(this, descriptor);
321
+ var StubNativeComponent = function(element) {
322
+ ReactComponent.Mixin.construct.call(this, element);
323
};
324
mixInto(StubNativeComponent, ReactComponent.Mixin);
325
mixInto(StubNativeComponent, ReactDOMComponent.Mixin);
src/browser/ui/__tests__/ReactMount-test.js
+2
-2
@@ -42,7 +42,7 @@ describe('ReactMount', function() {
42
expect(function() {
43
ReactTestUtils.renderIntoDocument('div');
44
}).toThrow(
45
- 'Invariant Violation: renderComponent(): Invalid component descriptor. ' +
45
+ 'Invariant Violation: renderComponent(): Invalid component element. ' +
46
'Instead of passing an element string, make sure to instantiate it ' +
47
'by passing it to React.createElement.'
48
);
@@ -57,7 +57,7 @@ describe('ReactMount', function() {
57
expect(function() {
58
ReactTestUtils.renderIntoDocument(Component);
59
}).toThrow(
60
- 'Invariant Violation: renderComponent(): Invalid component descriptor. ' +
60
+ 'Invariant Violation: renderComponent(): Invalid component element. ' +
61
'Instead of passing a component class, make sure to instantiate it ' +
62
'by passing it to React.createElement.'
63
);
src/browser/ui/dom/components/ReactDOMButton.js
+2
-2
@@ -21,13 +21,13 @@
21
var AutoFocusMixin = require('AutoFocusMixin');
22
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
23
var ReactCompositeComponent = require('ReactCompositeComponent');
24
-var ReactDescriptor = require('ReactDescriptor');
24
+var ReactElement = require('ReactElement');
25
var ReactDOM = require('ReactDOM');
26
27
var keyMirror = require('keyMirror');
28
29
// Store a reference to the <button> `ReactDOMComponent`. TODO: use string
30
-var button = ReactDescriptor.createFactory(ReactDOM.button.type);
30
+var button = ReactElement.createFactory(ReactDOM.button.type);
31
32
var mouseListenerNames = keyMirror({
33
onClick: true,
src/browser/ui/dom/components/ReactDOMForm.js
+2
-2
@@ -22,11 +22,11 @@ var EventConstants = require('EventConstants');
22
var LocalEventTrapMixin = require('LocalEventTrapMixin');
23
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
24
var ReactCompositeComponent = require('ReactCompositeComponent');
25
-var ReactDescriptor = require('ReactDescriptor');
25
+var ReactElement = require('ReactElement');
26
var ReactDOM = require('ReactDOM');
27
28
// Store a reference to the <form> `ReactDOMComponent`. TODO: use string
29
-var form = ReactDescriptor.createFactory(ReactDOM.form.type);
29
+var form = ReactElement.createFactory(ReactDOM.form.type);
30
31
/**
32
* Since onSubmit doesn't bubble OR capture on the top level in IE8, we need
src/browser/ui/dom/components/ReactDOMImg.js
+2
-2
@@ -22,11 +22,11 @@ var EventConstants = require('EventConstants');
22
var LocalEventTrapMixin = require('LocalEventTrapMixin');
23
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
24
var ReactCompositeComponent = require('ReactCompositeComponent');
25
-var ReactDescriptor = require('ReactDescriptor');
25
+var ReactElement = require('ReactElement');
26
var ReactDOM = require('ReactDOM');
27
28
// Store a reference to the <img> `ReactDOMComponent`. TODO: use string
29
-var img = ReactDescriptor.createFactory(ReactDOM.img.type);
29
+var img = ReactElement.createFactory(ReactDOM.img.type);
30
31
/**
32
* Since onLoad doesn't bubble OR capture on the top level in IE8, we need to
src/browser/ui/dom/components/ReactDOMInput.js
+2
-2
@@ -23,7 +23,7 @@ var DOMPropertyOperations = require('DOMPropertyOperations');
23
var LinkedValueUtils = require('LinkedValueUtils');
24
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
25
var ReactCompositeComponent = require('ReactCompositeComponent');
26
-var ReactDescriptor = require('ReactDescriptor');
26
+var ReactElement = require('ReactElement');
27
var ReactDOM = require('ReactDOM');
28
var ReactMount = require('ReactMount');
29
var ReactUpdates = require('ReactUpdates');
@@ -32,7 +32,7 @@ var invariant = require('invariant');
32
var merge = require('merge');
33
34
// Store a reference to the <input> `ReactDOMComponent`. TODO: use string
35
-var input = ReactDescriptor.createFactory(ReactDOM.input.type);
35
+var input = ReactElement.createFactory(ReactDOM.input.type);
36
37
var instancesByReactID = {};
38
src/browser/ui/dom/components/ReactDOMOption.js
+2
-2
@@ -20,13 +20,13 @@
20
21
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
22
var ReactCompositeComponent = require('ReactCompositeComponent');
23
-var ReactDescriptor = require('ReactDescriptor');
23
+var ReactElement = require('ReactElement');
24
var ReactDOM = require('ReactDOM');
25
26
var warning = require('warning');
27
28
// Store a reference to the <option> `ReactDOMComponent`. TODO: use string
29
-var option = ReactDescriptor.createFactory(ReactDOM.option.type);
29
+var option = ReactElement.createFactory(ReactDOM.option.type);
30
31
/**
32
* Implements an <option> native component that warns when `selected` is set.
src/browser/ui/dom/components/ReactDOMSelect.js
+2
-2
@@ -22,14 +22,14 @@ var AutoFocusMixin = require('AutoFocusMixin');
22
var LinkedValueUtils = require('LinkedValueUtils');
23
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
24
var ReactCompositeComponent = require('ReactCompositeComponent');
25
-var ReactDescriptor = require('ReactDescriptor');
25
+var ReactElement = require('ReactElement');
26
var ReactDOM = require('ReactDOM');
27
var ReactUpdates = require('ReactUpdates');
28
29
var merge = require('merge');
30
31
// Store a reference to the <select> `ReactDOMComponent`. TODO: use string
32
-var select = ReactDescriptor.createFactory(ReactDOM.select.type);
32
+var select = ReactElement.createFactory(ReactDOM.select.type);
33
34
function updateWithPendingValueIfMounted() {
35
/*jshint validthis:true */
src/browser/ui/dom/components/ReactDOMTextarea.js
+2
-2
@@ -23,7 +23,7 @@ var DOMPropertyOperations = require('DOMPropertyOperations');
23
var LinkedValueUtils = require('LinkedValueUtils');
24
var ReactBrowserComponentMixin = require('ReactBrowserComponentMixin');
25
var ReactCompositeComponent = require('ReactCompositeComponent');
26
-var ReactDescriptor = require('ReactDescriptor');
26
+var ReactElement = require('ReactElement');
27
var ReactDOM = require('ReactDOM');
28
var ReactUpdates = require('ReactUpdates');
29
@@ -33,7 +33,7 @@ var merge = require('merge');
33
var warning = require('warning');
34
35
// Store a reference to the <textarea> `ReactDOMComponent`. TODO: use string
36
-var textarea = ReactDescriptor.createFactory(ReactDOM.textarea.type);
36
+var textarea = ReactElement.createFactory(ReactDOM.textarea.type);
37
38
function forceUpdateIfMounted() {
39
/*jshint validthis:true */
src/browser/ui/dom/components/createFullPageComponent.js
+2
-2
@@ -21,7 +21,7 @@
21
22
// Defeat circular references by requiring this directly.
23
var ReactCompositeComponent = require('ReactCompositeComponent');
24
-var ReactDescriptor = require('ReactDescriptor');
24
+var ReactElement = require('ReactElement');
25
26
var invariant = require('invariant');
27
@@ -37,7 +37,7 @@ var invariant = require('invariant');
37
* @return {function} convenience constructor of new component
38
*/
39
function createFullPageComponent(tag) {
40
- var elementFactory = ReactDescriptor.createFactory(tag);
40
+ var elementFactory = ReactElement.createFactory(tag);
41
42
var FullPageComponent = ReactCompositeComponent.createClass({
43
displayName: 'ReactFullPageComponent' + tag,
src/core/ReactComponent.js
+50
-50
@@ -18,7 +18,7 @@
18
19
"use strict";
20
21
-var ReactDescriptor = require('ReactDescriptor');
21
+var ReactElement = require('ReactElement');
22
var ReactOwner = require('ReactOwner');
23
var ReactUpdates = require('ReactUpdates');
24
@@ -147,11 +147,11 @@ var ReactComponent = {
147
* @public
148
*/
149
setProps: function(partialProps, callback) {
150
- // Merge with the pending descriptor if it exists, otherwise with existing
151
- // descriptor props.
152
- var descriptor = this._pendingDescriptor || this._descriptor;
150
+ // Merge with the pending element if it exists, otherwise with existing
151
+ // element props.
152
+ var element = this._pendingElement || this._currentElement;
153
this.replaceProps(
154
- merge(descriptor.props, partialProps),
154
+ merge(element.props, partialProps),
155
callback
156
);
157
},
@@ -177,10 +177,10 @@ var ReactComponent = {
177
'`render` method to pass the correct value as props to the component ' +
178
'where it is created.'
179
);
180
- // This is a deoptimized path. We optimize for always having a descriptor.
181
- // This creates an extra internal descriptor.
182
- this._pendingDescriptor = ReactDescriptor.cloneAndReplaceProps(
183
- this._pendingDescriptor || this._descriptor,
180
+ // This is a deoptimized path. We optimize for always having a element.
181
+ // This creates an extra internal element.
182
+ this._pendingElement = ReactElement.cloneAndReplaceProps(
183
+ this._pendingElement || this._currentElement,
184
props
185
);
186
ReactUpdates.enqueueUpdate(this, callback);
@@ -195,12 +195,12 @@ var ReactComponent = {
195
* @internal
196
*/
197
_setPropsInternal: function(partialProps, callback) {
198
- // This is a deoptimized path. We optimize for always having a descriptor.
199
- // This creates an extra internal descriptor.
200
- var descriptor = this._pendingDescriptor || this._descriptor;
201
- this._pendingDescriptor = ReactDescriptor.cloneAndReplaceProps(
202
- descriptor,
203
- merge(descriptor.props, partialProps)
198
+ // This is a deoptimized path. We optimize for always having a element.
199
+ // This creates an extra internal element.
200
+ var element = this._pendingElement || this._currentElement;
201
+ this._pendingElement = ReactElement.cloneAndReplaceProps(
202
+ element,
203
+ merge(element.props, partialProps)
204
);
205
ReactUpdates.enqueueUpdate(this, callback);
206
},
@@ -211,19 +211,19 @@ var ReactComponent = {
211
* Subclasses that override this method should make sure to invoke
212
* `ReactComponent.Mixin.construct.call(this, ...)`.
213
*
214
- * @param {ReactDescriptor} descriptor
214
+ * @param {ReactElement} element
215
* @internal
216
*/
217
- construct: function(descriptor) {
217
+ construct: function(element) {
218
// This is the public exposed props object after it has been processed
219
- // with default props. The descriptor's props represents the true internal
219
+ // with default props. The element's props represents the true internal
220
// state of the props.
221
- this.props = descriptor.props;
221
+ this.props = element.props;
222
// Record the component responsible for creating this component.
223
- // This is accessible through the descriptor but we maintain an extra
223
+ // This is accessible through the element but we maintain an extra
224
// field for compatibility with devtools and as a way to make an
225
// incremental update. TODO: Consider deprecating this field.
226
- this._owner = descriptor._owner;
226
+ this._owner = element._owner;
227
228
// All components start unmounted.
229
this._lifeCycleState = ComponentLifeCycle.UNMOUNTED;
@@ -231,10 +231,10 @@ var ReactComponent = {
231
// See ReactUpdates.
232
this._pendingCallbacks = null;
233
234
- // We keep the old descriptor and a reference to the pending descriptor
234
+ // We keep the old element and a reference to the pending element
235
// to track updates.
236
- this._descriptor = descriptor;
237
- this._pendingDescriptor = null;
236
+ this._currentElement = element;
237
+ this._pendingElement = null;
238
},
239
240
/**
@@ -259,9 +259,9 @@ var ReactComponent = {
259
'single component instance in multiple places.',
260
rootID
261
);
262
- var ref = this._descriptor.ref;
262
+ var ref = this._currentElement.ref;
263
if (ref != null) {
264
- var owner = this._descriptor._owner;
264
+ var owner = this._currentElement._owner;
265
ReactOwner.addComponentAsRefTo(this, ref, owner);
266
}
267
this._rootNodeID = rootID;
@@ -285,7 +285,7 @@ var ReactComponent = {
285
this.isMounted(),
286
'unmountComponent(): Can only unmount a mounted component.'
287
);
288
- var ref = this._descriptor.ref;
288
+ var ref = this._currentElement.ref;
289
if (ref != null) {
290
ReactOwner.removeComponentAsRefFrom(this, ref, this._owner);
291
}
@@ -305,49 +305,49 @@ var ReactComponent = {
305
* @param {ReactReconcileTransaction} transaction
306
* @internal
307
*/
308
- receiveComponent: function(nextDescriptor, transaction) {
308
+ receiveComponent: function(nextElement, transaction) {
309
invariant(
310
this.isMounted(),
311
'receiveComponent(...): Can only update a mounted component.'
312
);
313
- this._pendingDescriptor = nextDescriptor;
313
+ this._pendingElement = nextElement;
314
this.performUpdateIfNecessary(transaction);
315
},
316
317
/**
318
- * If `_pendingDescriptor` is set, update the component.
318
+ * If `_pendingElement` is set, update the component.
319
*
320
* @param {ReactReconcileTransaction} transaction
321
* @internal
322
*/
323
performUpdateIfNecessary: function(transaction) {
324
- if (this._pendingDescriptor == null) {
324
+ if (this._pendingElement == null) {
325
return;
326
}
327
- var prevDescriptor = this._descriptor;
328
- var nextDescriptor = this._pendingDescriptor;
329
- this._descriptor = nextDescriptor;
330
- this.props = nextDescriptor.props;
331
- this._owner = nextDescriptor._owner;
332
- this._pendingDescriptor = null;
333
- this.updateComponent(transaction, prevDescriptor);
327
+ var prevElement = this._currentElement;
328
+ var nextElement = this._pendingElement;
329
+ this._currentElement = nextElement;
330
+ this.props = nextElement.props;
331
+ this._owner = nextElement._owner;
332
+ this._pendingElement = null;
333
+ this.updateComponent(transaction, prevElement);
334
},
335
336
/**
337
* Updates the component's currently mounted representation.
338
*
339
* @param {ReactReconcileTransaction} transaction
340
- * @param {object} prevDescriptor
340
+ * @param {object} prevElement
341
* @internal
342
*/
343
- updateComponent: function(transaction, prevDescriptor) {
344
- var nextDescriptor = this._descriptor;
343
+ updateComponent: function(transaction, prevElement) {
344
+ var nextElement = this._currentElement;
345
346
// If either the owner or a `ref` has changed, make sure the newest owner
347
// has stored a reference to `this`, and the previous owner (if different)
348
- // has forgotten the reference to `this`. We use the descriptor instead
348
+ // has forgotten the reference to `this`. We use the element instead
349
// of the public this.props because the post processing cannot determine
350
- // a ref. The ref conceptually lives on the descriptor.
350
+ // a ref. The ref conceptually lives on the element.
351
352
// TODO: Should this even be possible? The owner cannot change because
353
// it's forbidden by shouldUpdateReactComponent. The ref can change
@@ -355,19 +355,19 @@ var ReactComponent = {
355
// is made. It probably belongs where the key checking and
356
// instantiateReactComponent is done.
357
358
- if (nextDescriptor._owner !== prevDescriptor._owner ||
359
- nextDescriptor.ref !== prevDescriptor.ref) {
360
- if (prevDescriptor.ref != null) {
358
+ if (nextElement._owner !== prevElement._owner ||
359
+ nextElement.ref !== prevElement.ref) {
360
+ if (prevElement.ref != null) {
361
ReactOwner.removeComponentAsRefFrom(
362
- this, prevDescriptor.ref, prevDescriptor._owner
362
+ this, prevElement.ref, prevElement._owner
363
);
364
}
365
// Correct, even if the owner is the same, and only the ref has changed.
366
- if (nextDescriptor.ref != null) {
366
+ if (nextElement.ref != null) {
367
ReactOwner.addComponentAsRefTo(
368
this,
369
- nextDescriptor.ref,
370
- nextDescriptor._owner
369
+ nextElement.ref,
370
+ nextElement._owner
371
);
372
}
373
}
src/core/ReactCompositeComponent.js
+50
-50
@@ -21,11 +21,11 @@
21
var ReactComponent = require('ReactComponent');
22
var ReactContext = require('ReactContext');
23
var ReactCurrentOwner = require('ReactCurrentOwner');
24
-var ReactDescriptor = require('ReactDescriptor');
25
-var ReactDescriptorValidator = require('ReactDescriptorValidator');
24
+var ReactElement = require('ReactElement');
25
+var ReactElementValidator = require('ReactElementValidator');
26
var ReactEmptyComponent = require('ReactEmptyComponent');
27
var ReactErrorUtils = require('ReactErrorUtils');
28
-var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
28
+var ReactLegacyElement = require('ReactLegacyElement');
29
var ReactOwner = require('ReactOwner');
30
var ReactPerf = require('ReactPerf');
31
var ReactPropTransferer = require('ReactPropTransferer');
@@ -471,12 +471,12 @@ function mixSpecIntoComponent(Constructor, spec) {
471
}
472
473
invariant(
474
- !ReactLegacyDescriptor.isValidFactory(spec),
474
+ !ReactLegacyElement.isValidFactory(spec),
475
'ReactCompositeComponent: You\'re attempting to ' +
476
'use a component class as a mixin. Instead, just use a regular object.'
477
);
478
invariant(
479
- !ReactDescriptor.isValidDescriptor(spec),
479
+ !ReactElement.isValidElement(spec),
480
'ReactCompositeComponent: You\'re attempting to ' +
481
'use a component as a mixin. Instead, just use a regular object.'
482
);
@@ -713,11 +713,11 @@ var ReactCompositeComponentMixin = {
713
/**
714
* Base constructor for all composite component.
715
*
716
- * @param {ReactDescriptor} descriptor
716
+ * @param {ReactElement} element
717
* @final
718
* @internal
719
*/
720
- construct: function(descriptor) {
720
+ construct: function(element) {
721
// Children can be either an array or more than one argument
722
ReactComponent.Mixin.construct.apply(this, arguments);
723
ReactOwner.Mixin.construct.apply(this, arguments);
@@ -726,7 +726,7 @@ var ReactCompositeComponentMixin = {
726
this._pendingState = null;
727
728
// This is the public post-processed context. The real context and pending
729
- // context lives on the descriptor.
729
+ // context lives on the element.
730
this.context = null;
731
732
this._compositeLifeCycleState = null;
@@ -769,7 +769,7 @@ var ReactCompositeComponentMixin = {
769
this._bindAutoBindMethods();
770
}
771
772
- this.context = this._processContext(this._descriptor._context);
772
+ this.context = this._processContext(this._currentElement._context);
773
this.props = this._processProps(this.props);
774
775
this.state = this.getInitialState ? this.getInitialState() : null;
@@ -794,7 +794,7 @@ var ReactCompositeComponentMixin = {
794
795
this._renderedComponent = instantiateReactComponent(
796
this._renderValidatedComponent(),
797
- this._descriptor.type // The wrapping type
797
+ this._currentElement.type // The wrapping type
798
);
799
800
// Done with mounting, `setState` will now trigger UI changes.
@@ -987,7 +987,7 @@ var ReactCompositeComponentMixin = {
987
* @private
988
*/
989
_checkPropTypes: function(propTypes, props, location) {
990
- // TODO: Stop validating prop types here and only use the descriptor
990
+ // TODO: Stop validating prop types here and only use the element
991
// validation.
992
var componentName = this.constructor.displayName;
993
for (var propName in propTypes) {
@@ -1006,7 +1006,7 @@ var ReactCompositeComponentMixin = {
1006
},
1007
1008
/**
1009
- * If any of `_pendingDescriptor`, `_pendingState`, or `_pendingForceUpdate`
1009
+ * If any of `_pendingElement`, `_pendingState`, or `_pendingForceUpdate`
1010
* is set, update the component.
1011
*
1012
* @param {ReactReconcileTransaction} transaction
@@ -1021,7 +1021,7 @@ var ReactCompositeComponentMixin = {
1021
return;
1022
}
1023
1024
- if (this._pendingDescriptor == null &&
1024
+ if (this._pendingElement == null &&
1025
this._pendingState == null &&
1026
!this._pendingForceUpdate) {
1027
return;
@@ -1029,12 +1029,12 @@ var ReactCompositeComponentMixin = {
1029
1030
var nextContext = this.context;
1031
var nextProps = this.props;
1032
- var nextDescriptor = this._descriptor;
1033
- if (this._pendingDescriptor != null) {
1034
- nextDescriptor = this._pendingDescriptor;
1035
- nextContext = this._processContext(nextDescriptor._context);
1036
- nextProps = this._processProps(nextDescriptor.props);
1037
- this._pendingDescriptor = null;
1032
+ var nextElement = this._currentElement;
1033
+ if (this._pendingElement != null) {
1034
+ nextElement = this._pendingElement;
1035
+ nextContext = this._processContext(nextElement._context);
1036
+ nextProps = this._processProps(nextElement.props);
1037
+ this._pendingElement = null;
1038
1039
this._compositeLifeCycleState = CompositeLifeCycle.RECEIVING_PROPS;
1040
if (this.componentWillReceiveProps) {
@@ -1066,7 +1066,7 @@ var ReactCompositeComponentMixin = {
1066
this._pendingForceUpdate = false;
1067
// Will set `this.props`, `this.state` and `this.context`.
1068
this._performComponentUpdate(
1069
- nextDescriptor,
1069
+ nextElement,
1070
nextProps,
1071
nextState,
1072
nextContext,
@@ -1075,14 +1075,14 @@ var ReactCompositeComponentMixin = {
1075
} else {
1076
// If it's determined that a component should not update, we still want
1077
// to set props and state.
1078
- this._descriptor = nextDescriptor;
1078
+ this._currentElement = nextElement;
1079
this.props = nextProps;
1080
this.state = nextState;
1081
this.context = nextContext;
1082
1083
// Owner cannot change because shouldUpdateReactComponent doesn't allow
1084
// it. TODO: Remove this._owner completely.
1085
- this._owner = nextDescriptor._owner;
1085
+ this._owner = nextElement._owner;
1086
}
1087
},
1088
@@ -1090,7 +1090,7 @@ var ReactCompositeComponentMixin = {
1090
* Merges new props and state, notifies delegate methods of update and
1091
* performs update.
1092
*
1093
- * @param {ReactDescriptor} nextDescriptor Next descriptor
1093
+ * @param {ReactElement} nextElement Next element
1094
* @param {object} nextProps Next public object to set as properties.
1095
* @param {?object} nextState Next object to set as state.
1096
* @param {?object} nextContext Next public object to set as context.
@@ -1098,13 +1098,13 @@ var ReactCompositeComponentMixin = {
1098
* @private
1099
*/
1100
_performComponentUpdate: function(
1101
- nextDescriptor,
1101
+ nextElement,
1102
nextProps,
1103
nextState,
1104
nextContext,
1105
transaction
1106
) {
1107
- var prevDescriptor = this._descriptor;
1107
+ var prevElement = this._currentElement;
1108
var prevProps = this.props;
1109
var prevState = this.state;
1110
var prevContext = this.context;
@@ -1113,18 +1113,18 @@ var ReactCompositeComponentMixin = {
1113
this.componentWillUpdate(nextProps, nextState, nextContext);
1114
}
1115
1116
- this._descriptor = nextDescriptor;
1116
+ this._currentElement = nextElement;
1117
this.props = nextProps;
1118
this.state = nextState;
1119
this.context = nextContext;
1120
1121
// Owner cannot change because shouldUpdateReactComponent doesn't allow
1122
// it. TODO: Remove this._owner completely.
1123
- this._owner = nextDescriptor._owner;
1123
+ this._owner = nextElement._owner;
1124
1125
this.updateComponent(
1126
transaction,
1127
- prevDescriptor
1127
+ prevElement
1128
);
1129
1130
if (this.componentDidUpdate) {
@@ -1135,22 +1135,22 @@ var ReactCompositeComponentMixin = {
1135
}
1136
},
1137
1138
- receiveComponent: function(nextDescriptor, transaction) {
1139
- if (nextDescriptor === this._descriptor &&
1140
- nextDescriptor._owner != null) {
1141
- // Since descriptors are immutable after the owner is rendered,
1138
+ receiveComponent: function(nextElement, transaction) {
1139
+ if (nextElement === this._currentElement &&
1140
+ nextElement._owner != null) {
1141
+ // Since elements are immutable after the owner is rendered,
1142
// we can do a cheap identity compare here to determine if this is a
1143
// superfluous reconcile. It's possible for state to be mutable but such
1144
// change should trigger an update of the owner which would recreate
1145
- // the descriptor. We explicitly check for the existence of an owner since
1146
- // it's possible for a descriptor created outside a composite to be
1145
+ // the element. We explicitly check for the existence of an owner since
1146
+ // it's possible for a element created outside a composite to be
1147
// deeply mutated and reused.
1148
return;
1149
}
1150
1151
ReactComponent.Mixin.receiveComponent.call(
1152
this,
1153
- nextDescriptor,
1153
+ nextElement,
1154
transaction
1155
);
1156
},
@@ -1162,33 +1162,33 @@ var ReactCompositeComponentMixin = {
1162
* Sophisticated clients may wish to override this.
1163
*
1164
* @param {ReactReconcileTransaction} transaction
1165
- * @param {ReactDescriptor} prevDescriptor
1165
+ * @param {ReactElement} prevElement
1166
* @internal
1167
* @overridable
1168
*/
1169
updateComponent: ReactPerf.measure(
1170
'ReactCompositeComponent',
1171
'updateComponent',
1172
- function(transaction, prevParentDescriptor) {
1172
+ function(transaction, prevParentElement) {
1173
ReactComponent.Mixin.updateComponent.call(
1174
this,
1175
transaction,
1176
- prevParentDescriptor
1176
+ prevParentElement
1177
);
1178
1179
var prevComponentInstance = this._renderedComponent;
1180
- var prevDescriptor = prevComponentInstance._descriptor;
1181
- var nextDescriptor = this._renderValidatedComponent();
1182
- if (shouldUpdateReactComponent(prevDescriptor, nextDescriptor)) {
1183
- prevComponentInstance.receiveComponent(nextDescriptor, transaction);
1180
+ var prevElement = prevComponentInstance._currentElement;
1181
+ var nextElement = this._renderValidatedComponent();
1182
+ if (shouldUpdateReactComponent(prevElement, nextElement)) {
1183
+ prevComponentInstance.receiveComponent(nextElement, transaction);
1184
} else {
1185
// These two IDs are actually the same! But nothing should rely on that.
1186
var thisID = this._rootNodeID;
1187
var prevComponentID = prevComponentInstance._rootNodeID;
1188
prevComponentInstance.unmountComponent();
1189
this._renderedComponent = instantiateReactComponent(
1190
- nextDescriptor,
1191
- this._descriptor.type
1190
+ nextElement,
1191
+ this._currentElement.type
1192
);
1193
var nextMarkup = this._renderedComponent.mountComponent(
1194
thisID,
@@ -1245,7 +1245,7 @@ var ReactCompositeComponentMixin = {
1245
var renderedComponent;
1246
var previousContext = ReactContext.current;
1247
ReactContext.current = this._processChildContext(
1248
- this._descriptor._context
1248
+ this._currentElement._context
1249
);
1250
ReactCurrentOwner.current = this;
1251
try {
@@ -1261,7 +1261,7 @@ var ReactCompositeComponentMixin = {
1261
ReactCurrentOwner.current = null;
1262
}
1263
invariant(
1264
- ReactDescriptor.isValidDescriptor(renderedComponent),
1264
+ ReactElement.isValidElement(renderedComponent),
1265
'%s.render(): A valid ReactComponent must be returned. You may have ' +
1266
'returned undefined, an array or some other invalid object.',
1267
this.constructor.displayName || 'ReactCompositeComponent'
@@ -1406,12 +1406,12 @@ var ReactCompositeComponent = {
1406
}
1407
1408
if (__DEV__) {
1409
- return ReactLegacyDescriptor.wrapFactory(
1410
- ReactDescriptorValidator.createFactory(Constructor)
1409
+ return ReactLegacyElement.wrapFactory(
1410
+ ReactElementValidator.createFactory(Constructor)
1411
);
1412
}
1413
- return ReactLegacyDescriptor.wrapFactory(
1414
- ReactDescriptor.createFactory(Constructor)
1413
+ return ReactLegacyElement.wrapFactory(
1414
+ ReactElement.createFactory(Constructor)
1415
);
1416
},
1417
src/core/ReactElement.js
renamed
+29
-29
@@ -13,7 +13,7 @@
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*
16
- * @providesModule ReactDescriptor
16
+ * @providesModule ReactElement
17
*/
18
19
"use strict";
@@ -69,7 +69,7 @@ var useMutationMembrane = false;
69
* Warn for mutations.
70
*
71
* @internal
72
- * @param {object} descriptor
72
+ * @param {object} element
73
*/
74
function defineMutationMembrane(prototype) {
75
try {
@@ -86,7 +86,7 @@ function defineMutationMembrane(prototype) {
86
}
87
88
/**
89
- * Base constructor for all React descriptors. This is only used to make this
89
+ * Base constructor for all React elements. This is only used to make this
90
* work with a dynamic instanceof check. Nothing should live on this prototype.
91
*
92
* @param {*} type
@@ -95,13 +95,13 @@ function defineMutationMembrane(prototype) {
95
* @params {*} props
96
* @internal
97
*/
98
-var ReactDescriptor = function(type, key, ref, owner, context, props) {
99
- // Built-in properties that belong on the descriptor
98
+var ReactElement = function(type, key, ref, owner, context, props) {
99
+ // Built-in properties that belong on the element
100
this.type = type;
101
this.key = key;
102
this.ref = ref;
103
104
- // Record the component responsible for creating this descriptor.
104
+ // Record the component responsible for creating this element.
105
this._owner = owner;
106
107
// TODO: Deprecate withContext, and then the context becomes accessible
@@ -128,12 +128,12 @@ var ReactDescriptor = function(type, key, ref, owner, context, props) {
128
};
129
130
if (__DEV__) {
131
- defineMutationMembrane(ReactDescriptor.prototype);
131
+ defineMutationMembrane(ReactElement.prototype);
132
}
133
134
-ReactDescriptor.prototype._isReactDescriptor = true;
134
+ReactElement.prototype._isReactElement = true;
135
136
-ReactDescriptor.createDescriptor = function(type, config, children) {
136
+ReactElement.createElement = function(type, config, children) {
137
var propName;
138
139
// Reserved names are extracted
@@ -177,7 +177,7 @@ ReactDescriptor.createDescriptor = function(type, config, children) {
177
}
178
}
179
180
- return new ReactDescriptor(
180
+ return new ReactElement(
181
type,
182
key,
183
ref,
@@ -187,31 +187,31 @@ ReactDescriptor.createDescriptor = function(type, config, children) {
187
);
188
};
189
190
-ReactDescriptor.createFactory = function(type) {
191
- var factory = ReactDescriptor.createDescriptor.bind(null, type);
190
+ReactElement.createFactory = function(type) {
191
+ var factory = ReactElement.createElement.bind(null, type);
192
// Expose the type on the factory and the prototype so that it can be
193
- // easily accessed on descriptors. E.g. <Foo />.type === Foo.type.
193
+ // easily accessed on elements. E.g. <Foo />.type === Foo.type.
194
// This should not be named `constructor` since this may not be the function
195
- // that created the descriptor, and it may not even be a constructor.
195
+ // that created the element, and it may not even be a constructor.
196
factory.type = type;
197
return factory;
198
};
199
200
-ReactDescriptor.cloneAndReplaceProps = function(oldDescriptor, newProps) {
201
- var newDescriptor = new ReactDescriptor(
202
- oldDescriptor.type,
203
- oldDescriptor.key,
204
- oldDescriptor.ref,
205
- oldDescriptor._owner,
206
- oldDescriptor._context,
200
+ReactElement.cloneAndReplaceProps = function(oldElement, newProps) {
201
+ var newElement = new ReactElement(
202
+ oldElement.type,
203
+ oldElement.key,
204
+ oldElement.ref,
205
+ oldElement._owner,
206
+ oldElement._context,
207
newProps
208
);
209
210
if (__DEV__) {
211
// If the key on the original is valid, then the clone is valid
212
- newDescriptor._store.validated = oldDescriptor._store.validated;
212
+ newElement._store.validated = oldElement._store.validated;
213
}
214
- return newDescriptor;
214
+ return newElement;
215
};
216
217
/**
@@ -219,18 +219,18 @@ ReactDescriptor.cloneAndReplaceProps = function(oldDescriptor, newProps) {
219
* @return {boolean} True if `object` is a valid component.
220
* @final
221
*/
222
-ReactDescriptor.isValidDescriptor = function(object) {
222
+ReactElement.isValidElement = function(object) {
223
// ReactTestUtils is often used outside of beforeEach where as React is
224
// within it. This leads to two different instances of React on the same
225
- // page. To identify a descriptor from a different React instance we use
225
+ // page. To identify a element from a different React instance we use
226
// a flag instead of an instanceof check.
227
- var isDescriptor = !!(object && object._isReactDescriptor);
228
- // if (isDescriptor && !(object instanceof ReactDescriptor)) {
227
+ var isElement = !!(object && object._isReactElement);
228
+ // if (isElement && !(object instanceof ReactElement)) {
229
// This is an indicator that you're using multiple versions of React at the
230
// same time. This will screw with ownership and stuff. Fix it, please.
231
// TODO: We could possibly warn here.
232
// }
233
- return isDescriptor;
233
+ return isElement;
234
};
235
236
-module.exports = ReactDescriptor;
236
+module.exports = ReactElement;
src/core/ReactElementValidator.js
renamed
+17
-17
@@ -13,19 +13,19 @@
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*
16
- * @providesModule ReactDescriptorValidator
16
+ * @providesModule ReactElementValidator
17
*/
18
19
/**
20
- * ReactDescriptorValidator provides a wrapper around a descriptor factory
21
- * which validates the props passed to the descriptor. This is intended to be
20
+ * ReactElementValidator provides a wrapper around a element factory
21
+ * which validates the props passed to the element. This is intended to be
22
* used only in DEV and could be replaced by a static type checker for languages
23
* that support it.
24
*/
25
26
"use strict";
27
28
-var ReactDescriptor = require('ReactDescriptor');
28
+var ReactElement = require('ReactElement');
29
var ReactPropTypeLocations = require('ReactPropTypeLocations');
30
var ReactCurrentOwner = require('ReactCurrentOwner');
31
@@ -174,11 +174,11 @@ function validateChildKeys(component, parentType) {
174
if (Array.isArray(component)) {
175
for (var i = 0; i < component.length; i++) {
176
var child = component[i];
177
- if (ReactDescriptor.isValidDescriptor(child)) {
177
+ if (ReactElement.isValidElement(child)) {
178
validateExplicitKey(child, parentType);
179
}
180
}
181
- } else if (ReactDescriptor.isValidDescriptor(component)) {
181
+ } else if (ReactElement.isValidElement(component)) {
182
// This component was passed in a valid location.
183
component._store.validated = true;
184
} else if (component && typeof component === 'object') {
@@ -216,7 +216,7 @@ function checkPropTypes(componentName, propTypes, props, location) {
216
loggedTypeFailures[error.message] = true;
217
// This will soon use the warning module
218
monitorCodeUse(
219
- 'react_failed_descriptor_type_check',
219
+ 'react_failed_element_type_check',
220
{ message: error.message }
221
);
222
}
@@ -224,15 +224,15 @@ function checkPropTypes(componentName, propTypes, props, location) {
224
}
225
}
226
227
-var ReactDescriptorValidator = {
227
+var ReactElementValidator = {
228
229
- createDescriptor: function(type, props, children) {
230
- var descriptor = ReactDescriptor.createDescriptor.apply(this, arguments);
229
+ createElement: function(type, props, children) {
230
+ var element = ReactElement.createElement.apply(this, arguments);
231
232
// The result can be nullish if a mock or a custom function is used.
233
// TODO: Drop this when these are no longer allowed as the type argument.
234
- if (descriptor == null) {
235
- return descriptor;
234
+ if (element == null) {
235
+ return element;
236
}
237
238
for (var i = 2; i < arguments.length; i++) {
@@ -244,7 +244,7 @@ var ReactDescriptorValidator = {
244
checkPropTypes(
245
name,
246
type.propTypes,
247
- descriptor.props,
247
+ element.props,
248
ReactPropTypeLocations.prop
249
);
250
}
@@ -252,15 +252,15 @@ var ReactDescriptorValidator = {
252
checkPropTypes(
253
name,
254
type.contextTypes,
255
- descriptor._context,
255
+ element._context,
256
ReactPropTypeLocations.context
257
);
258
}
259
- return descriptor;
259
+ return element;
260
},
261
262
createFactory: function(type) {
263
- var validatedFactory = ReactDescriptorValidator.createDescriptor.bind(
263
+ var validatedFactory = ReactElementValidator.createElement.bind(
264
null,
265
type
266
);
@@ -270,4 +270,4 @@ var ReactDescriptorValidator = {
270
271
};
272
273
-module.exports = ReactDescriptorValidator;
273
+module.exports = ReactElementValidator;
src/core/ReactEmptyComponent.js
+2
-2
@@ -18,7 +18,7 @@
18
19
"use strict";
20
21
-var ReactDescriptor = require('ReactDescriptor');
21
+var ReactElement = require('ReactElement');
22
23
var invariant = require('invariant');
24
@@ -29,7 +29,7 @@ var nullComponentIdsRegistry = {};
29
30
var ReactEmptyComponentInjection = {
31
injectEmptyComponent: function(emptyComponent) {
32
- component = ReactDescriptor.createFactory(emptyComponent);
32
+ component = ReactElement.createFactory(emptyComponent);
33
}
34
};
35
src/core/ReactLegacyElement.js
renamed
+21
-21
@@ -13,7 +13,7 @@
13
* See the License for the specific language governing permissions and
14
* limitations under the License.
15
*
16
- * @providesModule ReactLegacyDescriptor
16
+ * @providesModule ReactLegacyElement
17
*/
18
19
"use strict";
@@ -26,7 +26,7 @@ var warning = require('warning');
26
27
var legacyFactoryLogs = {};
28
function warnForLegacyFactoryCall() {
29
- if (!ReactLegacyDescriptorFactory._isLegacyCallWarningEnabled) {
29
+ if (!ReactLegacyElementFactory._isLegacyCallWarningEnabled) {
30
return;
31
}
32
var owner = ReactCurrentOwner.current;
@@ -118,9 +118,9 @@ function proxyStaticMethods(target, source) {
118
var LEGACY_MARKER = {};
119
var NON_LEGACY_MARKER = {};
120
121
-var ReactLegacyDescriptorFactory = {};
121
+var ReactLegacyElementFactory = {};
122
123
-ReactLegacyDescriptorFactory.wrapCreateFactory = function(createFactory) {
123
+ReactLegacyElementFactory.wrapCreateFactory = function(createFactory) {
124
var legacyCreateFactory = function(type) {
125
if (typeof type !== 'function') {
126
// Non-function types cannot be legacy factories
@@ -154,11 +154,11 @@ ReactLegacyDescriptorFactory.wrapCreateFactory = function(createFactory) {
154
return legacyCreateFactory;
155
};
156
157
-ReactLegacyDescriptorFactory.wrapCreateDescriptor = function(createDescriptor) {
158
- var legacyCreateDescriptor = function(type, props, children) {
157
+ReactLegacyElementFactory.wrapCreateElement = function(createElement) {
158
+ var legacyCreateElement = function(type, props, children) {
159
if (typeof type !== 'function') {
160
// Non-function types cannot be legacy factories
161
- return createDescriptor.apply(this, arguments);
161
+ return createElement.apply(this, arguments);
162
}
163
164
var args;
@@ -172,7 +172,7 @@ ReactLegacyDescriptorFactory.wrapCreateDescriptor = function(createDescriptor) {
172
}
173
args = Array.prototype.slice.call(arguments, 0);
174
args[0] = type.type;
175
- return createDescriptor.apply(this, args);
175
+ return createElement.apply(this, args);
176
}
177
178
if (type.isReactLegacyFactory) {
@@ -186,7 +186,7 @@ ReactLegacyDescriptorFactory.wrapCreateDescriptor = function(createDescriptor) {
186
}
187
args = Array.prototype.slice.call(arguments, 0);
188
args[0] = type.type;
189
- return createDescriptor.apply(this, args);
189
+ return createElement.apply(this, args);
190
}
191
192
if (__DEV__) {
@@ -197,43 +197,43 @@ ReactLegacyDescriptorFactory.wrapCreateDescriptor = function(createDescriptor) {
197
// immediately as if this was used with legacy JSX.
198
return type.apply(null, Array.prototype.slice.call(arguments, 1));
199
};
200
- return legacyCreateDescriptor;
200
+ return legacyCreateElement;
201
};
202
203
-ReactLegacyDescriptorFactory.wrapFactory = function(factory) {
203
+ReactLegacyElementFactory.wrapFactory = function(factory) {
204
invariant(
205
typeof factory === 'function',
206
- 'This is suppose to accept a descriptor factory'
206
+ 'This is suppose to accept a element factory'
207
);
208
- var legacyDescriptorFactory = function(config, children) {
208
+ var legacyElementFactory = function(config, children) {
209
// This factory should not be called when JSX is used. Use JSX instead.
210
if (__DEV__) {
211
warnForLegacyFactoryCall();
212
}
213
return factory.apply(this, arguments);
214
};
215
- proxyStaticMethods(legacyDescriptorFactory, factory.type);
216
- legacyDescriptorFactory.isReactLegacyFactory = LEGACY_MARKER;
217
- legacyDescriptorFactory.type = factory.type;
218
- return legacyDescriptorFactory;
215
+ proxyStaticMethods(legacyElementFactory, factory.type);
216
+ legacyElementFactory.isReactLegacyFactory = LEGACY_MARKER;
217
+ legacyElementFactory.type = factory.type;
218
+ return legacyElementFactory;
219
};
220
221
// This is used to mark a factory that will remain. E.g. we're allowed to call
222
// it as a function. However, you're not suppose to pass it to createElement
223
// or createFactory, so it will warn you if you do.
224
-ReactLegacyDescriptorFactory.markNonLegacyFactory = function(factory) {
224
+ReactLegacyElementFactory.markNonLegacyFactory = function(factory) {
225
factory.isReactNonLegacyFactory = NON_LEGACY_MARKER;
226
return factory;
227
};
228
229
// Checks if a factory function is actually a legacy factory pretending to
230
// be a class.
231
-ReactLegacyDescriptorFactory.isValidFactory = function(factory) {
231
+ReactLegacyElementFactory.isValidFactory = function(factory) {
232
// TODO: This will be removed and moved into a class validator or something.
233
return typeof factory === 'function' &&
234
factory.isReactLegacyFactory === LEGACY_MARKER;
235
};
236
237
-ReactLegacyDescriptorFactory._isLegacyCallWarningEnabled = true;
237
+ReactLegacyElementFactory._isLegacyCallWarningEnabled = true;
238
239
-module.exports = ReactLegacyDescriptorFactory;
239
+module.exports = ReactLegacyElementFactory;
src/core/ReactMultiChild.js
+5
-5
@@ -286,12 +286,12 @@ var ReactMultiChild = {
286
continue;
287
}
288
var prevChild = prevChildren && prevChildren[name];
289
- var prevDescriptor = prevChild && prevChild._descriptor;
290
- var nextDescriptor = nextChildren[name];
291
- if (shouldUpdateReactComponent(prevDescriptor, nextDescriptor)) {
289
+ var prevElement = prevChild && prevChild._currentElement;
290
+ var nextElement = nextChildren[name];
291
+ if (shouldUpdateReactComponent(prevElement, nextElement)) {
292
this.moveChild(prevChild, nextIndex, lastIndex);
293
lastIndex = Math.max(prevChild._mountIndex, lastIndex);
294
- prevChild.receiveComponent(nextDescriptor, transaction);
294
+ prevChild.receiveComponent(nextElement, transaction);
295
prevChild._mountIndex = nextIndex;
296
} else {
297
if (prevChild) {
@@ -301,7 +301,7 @@ var ReactMultiChild = {
301
}
302
// The child must be instantiated before it's mounted.
303
var nextChildInstance = instantiateReactComponent(
304
- nextDescriptor,
304
+ nextElement,
305
null
306
);
307
this._mountChildByNameAtIndex(
src/core/ReactPropTransferer.js
+10
-10
@@ -129,21 +129,21 @@ var ReactPropTransferer = {
129
*
130
* This is usually used to pass down props to a returned root component.
131
*
132
- * @param {ReactDescriptor} descriptor Component receiving the properties.
133
- * @return {ReactDescriptor} The supplied `component`.
132
+ * @param {ReactElement} element Component receiving the properties.
133
+ * @return {ReactElement} The supplied `component`.
134
* @final
135
* @protected
136
*/
137
- transferPropsTo: function(descriptor) {
137
+ transferPropsTo: function(element) {
138
invariant(
139
- descriptor._owner === this,
139
+ element._owner === this,
140
'%s: You can\'t call transferPropsTo() on a component that you ' +
141
'don\'t own, %s. This usually means you are calling ' +
142
'transferPropsTo() on a component passed in as props or children.',
143
this.constructor.displayName,
144
- typeof descriptor.type === 'string' ?
145
- descriptor.type :
146
- descriptor.type.displayName
144
+ typeof element.type === 'string' ?
145
+ element.type :
146
+ element.type.displayName
147
);
148
149
if (__DEV__) {
@@ -157,11 +157,11 @@ var ReactPropTransferer = {
157
}
158
}
159
160
- // Because descriptors are immutable we have to merge into the existing
160
+ // Because elements are immutable we have to merge into the existing
161
// props object rather than clone it.
162
- transferInto(descriptor.props, this.props);
162
+ transferInto(element.props, this.props);
163
164
- return descriptor;
164
+ return element;
165
}
166
167
}
src/core/ReactPropTypes.js
+3
-3
@@ -18,7 +18,7 @@
18
19
"use strict";
20
21
-var ReactDescriptor = require('ReactDescriptor');
21
+var ReactElement = require('ReactElement');
22
var ReactPropTypeLocationNames = require('ReactPropTypeLocationNames');
23
24
var emptyFunction = require('emptyFunction');
@@ -160,7 +160,7 @@ function createArrayOfTypeChecker(typeChecker) {
160
161
function createComponentTypeChecker() {
162
function validate(props, propName, componentName, location) {
163
- if (!ReactDescriptor.isValidDescriptor(props[propName])) {
163
+ if (!ReactElement.isValidElement(props[propName])) {
164
var locationName = ReactPropTypeLocationNames[location];
165
return new Error(
166
`Invalid ${locationName} \`${propName}\` supplied to ` +
@@ -297,7 +297,7 @@ function isRenderable(propValue) {
297
if (Array.isArray(propValue)) {
298
return propValue.every(isRenderable);
299
}
300
- if (ReactDescriptor.isValidDescriptor(propValue)) {
300
+ if (ReactElement.isValidElement(propValue)) {
301
return true;
302
}
303
for (var k in propValue) {
src/core/__tests__/ReactComponent-test.js
+2
-2
@@ -139,9 +139,9 @@ describe('ReactComponent', function() {
139
}
140
});
141
142
- var descriptor = <Component />;
142
+ var element = <Component />;
143
144
- var instance = ReactTestUtils.renderIntoDocument(descriptor);
144
+ var instance = ReactTestUtils.renderIntoDocument(element);
145
expect(instance.isMounted()).toBeTruthy();
146
});
147
src/core/__tests__/ReactComponentLifeCycle-test.js
+4
-4
@@ -103,10 +103,10 @@ describe('ReactComponentLifeCycle', function() {
103
);
104
}
105
});
106
- var descriptor = <StatefulComponent />;
107
- var firstInstance = React.renderComponent(descriptor, container);
106
+ var element = <StatefulComponent />;
107
+ var firstInstance = React.renderComponent(element, container);
108
React.unmountComponentAtNode(container);
109
- var secondInstance = React.renderComponent(descriptor, container);
109
+ var secondInstance = React.renderComponent(element, container);
110
expect(firstInstance).not.toBe(secondInstance);
111
});
112
@@ -425,7 +425,7 @@ describe('ReactComponentLifeCycle', function() {
425
instance.setProps({text: "dos", tooltipText: "two"});
426
});
427
428
- it('should not allow setProps() called on an unmounted descriptor',
428
+ it('should not allow setProps() called on an unmounted element',
429
function() {
430
var PropsToUpdate = React.createClass({
431
render: function() {
src/core/__tests__/ReactCompositeComponent-test.js
+1
-1
@@ -114,7 +114,7 @@ describe('ReactCompositeComponent', function() {
114
it('should give context for PropType errors in nested components.', () => {
115
// In this test, we're making sure that if a proptype error is found in a
116
// component, we give a small hint as to which parent instantiated that
117
- // component as per warnings about key usage in ReactDescriptorValidator.
117
+ // component as per warnings about key usage in ReactElementValidator.
118
spyOn(console, 'warn');
119
var MyComp = React.createClass({
120
propTypes: {
src/core/__tests__/ReactDescriptor-test.js
+67
-67
@@ -20,16 +20,16 @@
20
"use strict";
21
22
var React;
23
-var ReactDescriptor;
23
+var ReactElement;
24
var ReactTestUtils;
25
26
-describe('ReactDescriptor', function() {
26
+describe('ReactElement', function() {
27
var ComponentFactory;
28
var ComponentClass;
29
30
beforeEach(function() {
31
React = require('React');
32
- ReactDescriptor = require('ReactDescriptor');
32
+ ReactElement = require('ReactElement');
33
ReactTestUtils = require('ReactTestUtils');
34
ComponentFactory = React.createClass({
35
render: function() { return <div />; }
@@ -37,61 +37,61 @@ describe('ReactDescriptor', function() {
37
ComponentClass = ComponentFactory.type;
38
});
39
40
- it('returns a complete descriptor according to spec', function() {
41
- var descriptor = React.createFactory(ComponentFactory)();
42
- expect(descriptor.type).toBe(ComponentClass);
43
- expect(descriptor.key).toBe(null);
44
- expect(descriptor.ref).toBe(null);
45
- expect(descriptor.props).toEqual({});
40
+ it('returns a complete element according to spec', function() {
41
+ var element = React.createFactory(ComponentFactory)();
42
+ expect(element.type).toBe(ComponentClass);
43
+ expect(element.key).toBe(null);
44
+ expect(element.ref).toBe(null);
45
+ expect(element.props).toEqual({});
46
});
47
48
it('allows a string to be passed as the type', function() {
49
- var descriptor = React.createFactory('div')();
50
- expect(descriptor.type).toBe('div');
51
- expect(descriptor.key).toBe(null);
52
- expect(descriptor.ref).toBe(null);
53
- expect(descriptor.props).toEqual({});
49
+ var element = React.createFactory('div')();
50
+ expect(element.type).toBe('div');
51
+ expect(element.key).toBe(null);
52
+ expect(element.ref).toBe(null);
53
+ expect(element.props).toEqual({});
54
});
55
56
- it('returns an immutable descriptor', function() {
57
- var descriptor = React.createFactory(ComponentFactory)();
58
- expect(() => descriptor.type = 'div').toThrow();
56
+ it('returns an immutable element', function() {
57
+ var element = React.createFactory(ComponentFactory)();
58
+ expect(() => element.type = 'div').toThrow();
59
});
60
61
it('does not reuse the original config object', function() {
62
var config = { foo: 1 };
63
- var descriptor = React.createFactory(ComponentFactory)(config);
64
- expect(descriptor.props.foo).toBe(1);
63
+ var element = React.createFactory(ComponentFactory)(config);
64
+ expect(element.props.foo).toBe(1);
65
config.foo = 2;
66
- expect(descriptor.props.foo).toBe(1);
66
+ expect(element.props.foo).toBe(1);
67
});
68
69
it('extracts key and ref from the config', function() {
70
- var descriptor = React.createFactory(ComponentFactory)({
70
+ var element = React.createFactory(ComponentFactory)({
71
key: '12',
72
ref: '34',
73
foo: '56'
74
});
75
- expect(descriptor.type).toBe(ComponentClass);
76
- expect(descriptor.key).toBe('12');
77
- expect(descriptor.ref).toBe('34');
78
- expect(descriptor.props).toEqual({foo:'56'});
75
+ expect(element.type).toBe(ComponentClass);
76
+ expect(element.key).toBe('12');
77
+ expect(element.ref).toBe('34');
78
+ expect(element.props).toEqual({foo:'56'});
79
});
80
81
it('coerces the key to a string', function() {
82
- var descriptor = React.createFactory(ComponentFactory)({
82
+ var element = React.createFactory(ComponentFactory)({
83
key: 12,
84
foo: '56'
85
});
86
- expect(descriptor.type).toBe(ComponentClass);
87
- expect(descriptor.key).toBe('12');
88
- expect(descriptor.ref).toBe(null);
89
- expect(descriptor.props).toEqual({foo:'56'});
86
+ expect(element.type).toBe(ComponentClass);
87
+ expect(element.key).toBe('12');
88
+ expect(element.ref).toBe(null);
89
+ expect(element.props).toEqual({foo:'56'});
90
});
91
92
- it('preserves the context on the descriptor', function() {
92
+ it('preserves the context on the element', function() {
93
var Component = React.createFactory(ComponentFactory);
94
- var descriptor;
94
+ var element;
95
96
var Wrapper = React.createClass({
97
childContextTypes: {
@@ -101,19 +101,19 @@ describe('ReactDescriptor', function() {
101
return { foo: 'bar' };
102
},
103
render: function() {
104
- descriptor = Component();
105
- return descriptor;
104
+ element = Component();
105
+ return element;
106
}
107
});
108
109
ReactTestUtils.renderIntoDocument(<Wrapper />);
110
111
- expect(descriptor._context).toEqual({ foo: 'bar' });
111
+ expect(element._context).toEqual({ foo: 'bar' });
112
});
113
114
- it('preserves the owner on the descriptor', function() {
114
+ it('preserves the owner on the element', function() {
115
var Component = React.createFactory(ComponentFactory);
116
- var descriptor;
116
+ var element;
117
118
var Wrapper = React.createClass({
119
childContextTypes: {
@@ -123,53 +123,53 @@ describe('ReactDescriptor', function() {
123
return { foo: 'bar' };
124
},
125
render: function() {
126
- descriptor = Component();
127
- return descriptor;
126
+ element = Component();
127
+ return element;
128
}
129
});
130
131
var instance = ReactTestUtils.renderIntoDocument(<Wrapper />);
132
133
- expect(descriptor._owner).toBe(instance);
133
+ expect(element._owner).toBe(instance);
134
});
135
136
it('merges an additional argument onto the children prop', function() {
137
spyOn(console, 'warn');
138
var a = 1;
139
- var descriptor = React.createFactory(ComponentFactory)({
139
+ var element = React.createFactory(ComponentFactory)({
140
children: 'text'
141
}, a);
142
- expect(descriptor.props.children).toBe(a);
142
+ expect(element.props.children).toBe(a);
143
expect(console.warn.argsForCall.length).toBe(0);
144
});
145
146
it('does not override children if no rest args are provided', function() {
147
spyOn(console, 'warn');
148
- var descriptor = React.createFactory(ComponentFactory)({
148
+ var element = React.createFactory(ComponentFactory)({
149
children: 'text'
150
});
151
- expect(descriptor.props.children).toBe('text');
151
+ expect(element.props.children).toBe('text');
152
expect(console.warn.argsForCall.length).toBe(0);
153
});
154
155
it('overrides children if null is provided as an argument', function() {
156
spyOn(console, 'warn');
157
- var descriptor = React.createFactory(ComponentFactory)({
157
+ var element = React.createFactory(ComponentFactory)({
158
children: 'text'
159
}, null);
160
- expect(descriptor.props.children).toBe(null);
160
+ expect(element.props.children).toBe(null);
161
expect(console.warn.argsForCall.length).toBe(0);
162
});
163
164
it('merges rest arguments onto the children prop in an array', function() {
165
spyOn(console, 'warn');
166
var a = 1, b = 2, c = 3;
167
- var descriptor = React.createFactory(ComponentFactory)(null, a, b, c);
168
- expect(descriptor.props.children).toEqual([1, 2, 3]);
167
+ var element = React.createFactory(ComponentFactory)(null, a, b, c);
168
+ expect(element.props.children).toEqual([1, 2, 3]);
169
expect(console.warn.argsForCall.length).toBe(0);
170
});
171
172
- it('warns for keys for arrays of descriptors in rest args', function() {
172
+ it('warns for keys for arrays of elements in rest args', function() {
173
spyOn(console, 'warn');
174
var Component = React.createFactory(ComponentFactory);
175
@@ -181,7 +181,7 @@ describe('ReactDescriptor', function() {
181
);
182
});
183
184
- it('does not warn when the descriptor is directly in rest args', function() {
184
+ it('does not warn when the element is directly in rest args', function() {
185
spyOn(console, 'warn');
186
var Component = React.createFactory(ComponentFactory);
187
@@ -190,7 +190,7 @@ describe('ReactDescriptor', function() {
190
expect(console.warn.argsForCall.length).toBe(0);
191
});
192
193
- it('does not warn when the array contains a non-descriptor', function() {
193
+ it('does not warn when the array contains a non-element', function() {
194
spyOn(console, 'warn');
195
var Component = React.createFactory(ComponentFactory);
196
@@ -216,27 +216,27 @@ describe('ReactDescriptor', function() {
216
}
217
});
218
219
- var descriptor = <ComponentClass />;
220
- expect(descriptor.type.someStaticMethod()).toBe('someReturnValue');
219
+ var element = <ComponentClass />;
220
+ expect(element.type.someStaticMethod()).toBe('someReturnValue');
221
expect(console.warn.argsForCall.length).toBe(0);
222
});
223
224
- it('identifies valid descriptors', function() {
224
+ it('identifies valid elements', function() {
225
var Component = React.createClass({
226
render: function() {
227
return <div />;
228
}
229
});
230
231
- expect(ReactDescriptor.isValidDescriptor(<div />)).toEqual(true);
232
- expect(ReactDescriptor.isValidDescriptor(<Component />)).toEqual(true);
231
+ expect(ReactElement.isValidElement(<div />)).toEqual(true);
232
+ expect(ReactElement.isValidElement(<Component />)).toEqual(true);
233
234
- expect(ReactDescriptor.isValidDescriptor(null)).toEqual(false);
235
- expect(ReactDescriptor.isValidDescriptor(true)).toEqual(false);
236
- expect(ReactDescriptor.isValidDescriptor({})).toEqual(false);
237
- expect(ReactDescriptor.isValidDescriptor("string")).toEqual(false);
238
- expect(ReactDescriptor.isValidDescriptor(React.DOM.div)).toEqual(false);
239
- expect(ReactDescriptor.isValidDescriptor(Component)).toEqual(false);
234
+ expect(ReactElement.isValidElement(null)).toEqual(false);
235
+ expect(ReactElement.isValidElement(true)).toEqual(false);
236
+ expect(ReactElement.isValidElement({})).toEqual(false);
237
+ expect(ReactElement.isValidElement("string")).toEqual(false);
238
+ expect(ReactElement.isValidElement(React.DOM.div)).toEqual(false);
239
+ expect(ReactElement.isValidElement(Component)).toEqual(false);
240
});
241
242
it('warns but allow a plain function in a factory to be invoked', function() {
@@ -256,7 +256,7 @@ describe('ReactDescriptor', function() {
256
257
it('warns but allow a plain function to be immediately invoked', function() {
258
spyOn(console, 'warn');
259
- var result = React.createDescriptor(function (x, y) {
259
+ var result = React.createElement(function (x, y) {
260
return 21 + x + y;
261
}, 11, 10);
262
expect(result).toBe(42);
@@ -269,7 +269,7 @@ describe('ReactDescriptor', function() {
269
it('warns but does not fail on undefined results', function() {
270
spyOn(console, 'warn');
271
var fn = function () { };
272
- var result = React.createDescriptor(fn, 1, 2, null);
272
+ var result = React.createElement(fn, 1, 2, null);
273
expect(result).toBe(undefined);
274
expect(console.warn.argsForCall.length).toBe(1);
275
expect(console.warn.argsForCall[0][0]).toContain(
@@ -297,9 +297,9 @@ describe('ReactDescriptor', function() {
297
expect(typeof Component.specialType.isRequired).toBe("function");
298
});
299
300
- it('allows a DOM descriptor to be used with a string', function() {
301
- var descriptor = React.createDescriptor('div', { className: 'foo' });
302
- var instance = ReactTestUtils.renderIntoDocument(descriptor);
300
+ it('allows a DOM element to be used with a string', function() {
301
+ var element = React.createElement('div', { className: 'foo' });
302
+ var instance = ReactTestUtils.renderIntoDocument(element);
303
expect(instance.getDOMNode().tagName).toBe('DIV');
304
});
305
src/core/instantiateReactComponent.js
+22
-23
@@ -21,48 +21,47 @@
21
22
var warning = require('warning');
23
24
-var ReactDescriptor = require('ReactDescriptor');
25
-var ReactLegacyDescriptor = require('ReactLegacyDescriptor');
24
+var ReactElement = require('ReactElement');
25
+var ReactLegacyElement = require('ReactLegacyElement');
26
var ReactNativeComponent = require('ReactNativeComponent');
27
var ReactEmptyComponent = require('ReactEmptyComponent');
28
29
/**
30
- * Given a `componentDescriptor` create an instance that will actually be
31
- * mounted.
30
+ * Given an `element` create an instance that will actually be mounted.
31
*
33
- * @param {object} descriptor
32
+ * @param {object} element
33
* @param {*} parentCompositeType The composite type that resolved this.
35
- * @return {object} A new instance of the descriptor's constructor.
34
+ * @return {object} A new instance of the element's constructor.
35
* @protected
36
*/
38
-function instantiateReactComponent(descriptor, parentCompositeType) {
37
+function instantiateReactComponent(element, parentCompositeType) {
38
var instance;
39
40
if (__DEV__) {
41
warning(
43
- descriptor && (typeof descriptor.type === 'function' ||
44
- typeof descriptor.type === 'string'),
42
+ element && (typeof element.type === 'function' ||
43
+ typeof element.type === 'string'),
44
'Only functions or strings can be mounted as React components.'
45
);
46
47
// Resolve mock instances
49
- if (descriptor.type._mockedReactClassConstructor) {
48
+ if (element.type._mockedReactClassConstructor) {
49
// If this is a mocked class, we treat the legacy factory as if it was the
50
// class constructor for future proofing unit tests. Because this might
51
// be mocked as a legacy factory, we ignore any warnings triggerd by
52
// this temporary hack.
54
- ReactLegacyDescriptor._isLegacyCallWarningEnabled = false;
53
+ ReactLegacyElement._isLegacyCallWarningEnabled = false;
54
try {
56
- instance = new descriptor.type._mockedReactClassConstructor(
57
- descriptor.props
55
+ instance = new element.type._mockedReactClassConstructor(
56
+ element.props
57
);
58
} finally {
60
- ReactLegacyDescriptor._isLegacyCallWarningEnabled = true;
59
+ ReactLegacyElement._isLegacyCallWarningEnabled = true;
60
}
61
62
// If the mock implementation was a legacy factory, then it returns a
64
- // descriptor. We need to turn this into a real component instance.
65
- if (ReactDescriptor.isValidDescriptor(instance)) {
63
+ // element. We need to turn this into a real component instance.
64
+ if (ReactElement.isValidElement(instance)) {
65
instance = new instance.type(instance.props);
66
}
67
@@ -71,7 +70,7 @@ function instantiateReactComponent(descriptor, parentCompositeType) {
70
// For auto-mocked factories, the prototype isn't shimmed and therefore
71
// there is no render function on the instance. We replace the whole
72
// component with an empty component instance instead.
74
- descriptor = ReactEmptyComponent.getEmptyComponent();
73
+ element = ReactEmptyComponent.getEmptyComponent();
74
} else {
75
if (render._isMockFunction && !render._getMockImplementation()) {
76
// Auto-mocked components may have a prototype with a mocked render
@@ -81,22 +80,22 @@ function instantiateReactComponent(descriptor, parentCompositeType) {
80
ReactEmptyComponent.getEmptyComponent
81
);
82
}
84
- instance.construct(descriptor);
83
+ instance.construct(element);
84
return instance;
85
}
86
}
87
}
88
89
// Special case string values
91
- if (typeof descriptor.type === 'string') {
90
+ if (typeof element.type === 'string') {
91
instance = ReactNativeComponent.createInstanceForTag(
93
- descriptor.type,
94
- descriptor.props,
92
+ element.type,
93
+ element.props,
94
parentCompositeType
95
);
96
} else {
97
// Normal case for non-mocks and non-strings
99
- instance = new descriptor.type(descriptor.props);
98
+ instance = new element.type(element.props);
99
}
100
101
if (__DEV__) {
@@ -110,7 +109,7 @@ function instantiateReactComponent(descriptor, parentCompositeType) {
109
110
// This actually sets up the internal instance. This will become decoupled
111
// from the public instance in a future diff.
113
- instance.construct(descriptor);
112
+ instance.construct(element);
113
114
return instance;
115
}
src/core/shouldUpdateReactComponent.js
+9
-9
@@ -20,21 +20,21 @@
20
"use strict";
21
22
/**
23
- * Given a `prevDescriptor` and `nextDescriptor`, determines if the existing
23
+ * Given a `prevElement` and `nextElement`, determines if the existing
24
* instance should be updated as opposed to being destroyed or replaced by a new
25
- * instance. Both arguments are descriptors. This ensures that this logic can
25
+ * instance. Both arguments are elements. This ensures that this logic can
26
* operate on stateless trees without any backing instance.
27
*
28
- * @param {?object} prevDescriptor
29
- * @param {?object} nextDescriptor
28
+ * @param {?object} prevElement
29
+ * @param {?object} nextElement
30
* @return {boolean} True if the existing instance should be updated.
31
* @protected
32
*/
33
-function shouldUpdateReactComponent(prevDescriptor, nextDescriptor) {
34
- if (prevDescriptor && nextDescriptor &&
35
- prevDescriptor.type === nextDescriptor.type &&
36
- prevDescriptor.key === nextDescriptor.key &&
37
- prevDescriptor._owner === nextDescriptor._owner) {
33
+function shouldUpdateReactComponent(prevElement, nextElement) {
34
+ if (prevElement && nextElement &&
35
+ prevElement.type === nextElement.type &&
36
+ prevElement.key === nextElement.key &&
37
+ prevElement._owner === nextElement._owner) {
38
return true;
39
}
40
return false;
src/test/ReactTestUtils.js
+11
-11
@@ -22,7 +22,7 @@ var EventConstants = require('EventConstants');
22
var EventPluginHub = require('EventPluginHub');
23
var EventPropagators = require('EventPropagators');
24
var React = require('React');
25
-var ReactDescriptor = require('ReactDescriptor');
25
+var ReactElement = require('ReactElement');
26
var ReactBrowserEventEmitter = require('ReactBrowserEventEmitter');
27
var ReactMount = require('ReactMount');
28
var ReactTextComponent = require('ReactTextComponent');
@@ -55,13 +55,13 @@ var ReactTestUtils = {
55
return React.renderComponent(instance, div);
56
},
57
58
- isDescriptor: function(descriptor) {
59
- return ReactDescriptor.isValidDescriptor(descriptor);
58
+ isElement: function(element) {
59
+ return ReactElement.isValidElement(element);
60
},
61
62
- isDescriptorOfType: function(inst, convenienceConstructor) {
62
+ isElementOfType: function(inst, convenienceConstructor) {
63
return (
64
- ReactDescriptor.isValidDescriptor(inst) &&
64
+ ReactElement.isValidElement(inst) &&
65
inst.type === convenienceConstructor.type
66
);
67
},
@@ -70,9 +70,9 @@ var ReactTestUtils = {
70
return !!(inst && inst.mountComponent && inst.tagName);
71
},
72
73
- isDOMComponentDescriptor: function(inst) {
73
+ isDOMComponentElement: function(inst) {
74
return !!(inst &&
75
- ReactDescriptor.isValidDescriptor(inst) &&
75
+ ReactElement.isValidElement(inst) &&
76
!!inst.tagName);
77
},
78
@@ -86,8 +86,8 @@ var ReactTestUtils = {
86
(inst.constructor === type.type));
87
},
88
89
- isCompositeComponentDescriptor: function(inst) {
90
- if (!ReactDescriptor.isValidDescriptor(inst)) {
89
+ isCompositeComponentElement: function(inst) {
90
+ if (!ReactElement.isValidElement(inst)) {
91
return false;
92
}
93
// We check the prototype of the type that will get mounted, not the
@@ -99,8 +99,8 @@ var ReactTestUtils = {
99
);
100
},
101
102
- isCompositeComponentDescriptorWithType: function(inst, type) {
103
- return !!(ReactTestUtils.isCompositeComponentDescriptor(inst) &&
102
+ isCompositeComponentElementWithType: function(inst, type) {
103
+ return !!(ReactTestUtils.isCompositeComponentElement(inst) &&
104
(inst.constructor === type));
105
},
106
src/test/reactComponentExpect.js
+3
-3
@@ -35,7 +35,7 @@ function reactComponentExpect(instance) {
35
this._instance = instance;
36
expect(typeof instance).toBe('object');
37
expect(typeof instance.constructor).toBe('function');
38
- expect(ReactTestUtils.isDescriptor(instance)).toBe(false);
38
+ expect(ReactTestUtils.isElement(instance)).toBe(false);
39
}
40
41
mergeInto(reactComponentExpect.prototype, {
@@ -109,7 +109,7 @@ mergeInto(reactComponentExpect.prototype, {
109
convenienceConstructor :
110
convenienceConstructor.type;
111
expect(
112
- this.instance()._descriptor.type === type
112
+ this.instance()._currentElement.type === type
113
).toBe(true);
114
return this;
115
},
@@ -129,7 +129,7 @@ mergeInto(reactComponentExpect.prototype, {
129
toBeCompositeComponentWithType: function(convenienceConstructor) {
130
this.toBeCompositeComponent();
131
expect(
132
- this.instance()._descriptor.type === convenienceConstructor.type
132
+ this.instance()._currentElement.type === convenienceConstructor.type
133
).toBe(true);
134
return this;
135
},
src/utils/cloneWithProps.js
+3
-3
@@ -19,7 +19,7 @@
19
20
"use strict";
21
22
-var ReactDescriptor = require('ReactDescriptor');
22
+var ReactElement = require('ReactElement');
23
var ReactPropTransferer = require('ReactPropTransferer');
24
25
var keyOf = require('keyOf');
@@ -55,8 +55,8 @@ function cloneWithProps(child, props) {
55
}
56
57
// The current API doesn't retain _owner and _context, which is why this
58
- // doesn't use ReactDescriptor.cloneAndReplaceProps.
59
- return ReactDescriptor.createDescriptor(child.type, newProps);
58
+ // doesn't use ReactElement.cloneAndReplaceProps.
59
+ return ReactElement.createElement(child.type, newProps);
60
}
61
62
module.exports = cloneWithProps;
src/utils/onlyChild.js
+2
-2
@@ -17,7 +17,7 @@
17
*/
18
"use strict";
19
20
-var ReactDescriptor = require('ReactDescriptor');
20
+var ReactElement = require('ReactElement');
21
22
var invariant = require('invariant');
23
@@ -34,7 +34,7 @@ var invariant = require('invariant');
34
*/
35
function onlyChild(children) {
36
invariant(
37
- ReactDescriptor.isValidDescriptor(children),
37
+ ReactElement.isValidElement(children),
38
'onlyChild must be passed a children with exactly one child.'
39
);
40
return children;
src/utils/traverseAllChildren.js
+2
-2
@@ -18,7 +18,7 @@
18
19
"use strict";
20
21
-var ReactDescriptor = require('ReactDescriptor');
21
+var ReactElement = require('ReactElement');
22
var ReactInstanceHandles = require('ReactInstanceHandles');
23
24
var invariant = require('invariant');
@@ -128,7 +128,7 @@ var traverseAllChildrenImpl =
128
callback(traverseContext, null, storageName, indexSoFar);
129
subtreeCount = 1;
130
} else if (type === 'string' || type === 'number' ||
131
- ReactDescriptor.isValidDescriptor(children)) {
131
+ ReactElement.isValidElement(children)) {
132
callback(traverseContext, children, storageName, indexSoFar);
133
subtreeCount = 1;
134
} else if (type === 'object') {