var ReactPIXI_updateRenderedComponent = function(transaction, context) {
var prevComponentInstance = this._renderedComponent;
// Find the first actual rendered (non-Composite) component.
// If that component is a PIXI node we use the special code here.
// If not, we call back to the original version of updateComponent
// which should handle all non-PIXI nodes.
var prevDisplayObject = findDisplayObjectChild(prevComponentInstance);
if (!prevDisplayObject) {
// not a PIXI node, use the original DOM-style version
old_updateRenderedComponent.call(this,transaction, context);
return;
}
// This is a PIXI node, do a special PIXI version of updateComponent
var prevRenderedElement = prevComponentInstance._currentElement;
var nextRenderedElement = this._renderValidatedComponent();
if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) {
ReactReconciler.receiveComponent(
prevComponentInstance,
nextRenderedElement,
transaction,
this._processChildContext(context)
);
} else {
// We can't just update the current component.
// So we nuke the current instantiated component and put a new component in
// the same place based on the new props.
var thisID = this._rootNodeID;
var displayObjectParent = prevDisplayObject.parent;
// unmounting doesn't disconnect the child from the parent node,
// but later on we'll simply overwrite the proper element in the 'children' data member
var displayObjectIndex = displayObjectParent.children.indexOf(prevDisplayObject);
ReactReconciler.unmountComponent(prevComponentInstance);
displayObjectParent.removeChild(prevDisplayObject);
// create the new object and stuff it into the place vacated by the old object
this._renderedComponent = this._instantiateReactComponent(
nextRenderedElement,
this._currentElement.type);
var nextDisplayObject = ReactReconciler.mountComponent(
this._renderedComponent,
thisID,
transaction,
this._processChildContext(context)
);
this._renderedComponent._displayObject = nextDisplayObject;
// fixup _mountImage as well
this._mountImage = nextDisplayObject;
// overwrite the reference to the old child
displayObjectParent.addChildAt(nextDisplayObject, displayObjectIndex);
}
};
'it by passing it to React.createElement.' :
// Check if it quacks like an element
nextElement != null && nextElement.props !== undefined ?
' This may be caused by unintentionally loading two independent ' +
'copies of React.' :
''
)
);
if (umgWidget) {
const prevComponent = umgWidget.component;
if (prevComponent) {
const prevWrappedElement = prevComponent._currentElement;
const prevElement = prevWrappedElement.props;
if (shouldUpdateReactComponent(prevElement, nextElement)) {
// $FlowFixMe
const publicInst = prevComponent._renderedComponent.getPublicInstance();
const updatedCallback = callback && function() {
// appease flow
if (callback) {
callback.call(publicInst);
}
};
ReactUMGMount._updateRootComponent(
prevComponent,
nextElement,
container,
updatedCallback
);
_renderSubtreeIntoContainer(parentComponent, nextElement, container, callback) {
if (!reactElementWrapper.isValidElement(nextElement)) {
if (process.env.NODE_ENV !== 'production') {
if (typeof nextElement === 'string') {
invariant(false, 'React3Renderer.render(): Invalid component element.%s',
' Instead of passing an element string, make sure to instantiate ' +
'it by passing it to React.createElement.');
} else {
if (typeof nextElement === 'function') {
invariant(false, 'React3Renderer.render(): Invalid component element.%s',
' Instead of passing a component class, make sure to instantiate ' +
'it by passing it to React.createElement.');
} else {
if (nextElement !== null && nextElement.props !== undefined) {
invariant(false, 'React3Renderer.render(): Invalid component element.%s',
' This may be caused by unintentionally loading two independent ' +
'copies of React.');
} else {
invariant(false, 'React3Renderer.render(): Invalid component element.');
}
}
}
} else {
invariant(false);
}
}
const nextWrappedElement = reactElementWrapper(TopLevelWrapper,
null, null, null, null, null, nextElement);
let nextContext;
if (parentComponent) {
const parentInst = ReactInstanceMap.get(parentComponent);
nextContext = parentInst._processChildContext(parentInst._context);
} else {
nextContext = emptyObject;
}
const prevComponent = this.getTopLevelWrapperInContainer(container);
if (prevComponent) {
const prevWrappedElement = prevComponent._currentElement;
const prevElement = prevWrappedElement.props;
if (shouldUpdateReactComponent(prevElement, nextElement)) {
const publicInst = prevComponent._renderedComponent.getPublicInstance();
const updatedCallback = callback &&
(() => {
callback.call(publicInst);
});
this._updateRootComponent(prevComponent,
nextWrappedElement,
nextContext,
container,
updatedCallback);
return publicInst;
}
this.unmountComponentAtNode(container);
}
// aka first child
const reactRootMarkup = getReactRootMarkupInContainer(container);
const containerHasReactMarkup = reactRootMarkup && !!internalGetID(reactRootMarkup);
// containerHasNonRootReactChild not implemented
const shouldReuseMarkup = containerHasReactMarkup && !prevComponent;
const component = this._renderNewRootComponent(
nextWrappedElement,
container,
shouldReuseMarkup,
nextContext
)._renderedComponent.getPublicInstance();
if (callback) {
callback.call(component);
}
return component;
}
/**
* @see ReactChildReconciler.updateChildren
*
* Updates the rendered children and returns a new set of children.
*
* @param {?object} prevChildren Previously initialized set of children.
* @param {?object} nextChildren Flat child element maps.
* @param {?object} removedMarkups The map for removed nodes.
* @param {ReactReconcileTransaction} transaction
* @param {object} context
* @return {?object} A new set of child instances.
* @internal
*/
updateChildren(prevChildren,
nextChildren,
removedMarkups,
transaction,
context) {
// We currently don't have a way to track moves here but if we use iterators
// instead of for..in we can zip the iterators and check if an item has
// moved.
// TODO: If nothing has changed, return the prevChildren object so that we
// can quickly bailout.
if (!nextChildren && !prevChildren) {
return null;
}
if (!!nextChildren) {
const nextChildrenKeys = Object.keys(nextChildren);
for (let i = 0; i < nextChildrenKeys.length; ++i) {
const childName = nextChildrenKeys[i];
const prevChild = prevChildren && prevChildren[childName];
const prevElement = prevChild && prevChild._currentElement;
const nextElement = nextChildren[childName];
if (prevChild !== null && prevChild !== undefined
&& shouldUpdateReactComponent(prevElement, nextElement)) {
ReactReconciler.receiveComponent(
prevChild, nextElement, transaction, context
);
if (prevChild._forceRemountOfComponent) {
removedMarkups[childName] = prevChild.getHostMarkup();
ReactReconciler.unmountComponent(prevChild, false);
nextChildren[childName] = this.instantiateReactComponent(nextElement, true);
} else {
nextChildren[childName] = prevChild;
}
} else {
if (prevChild) {
removedMarkups[childName] = prevChild.getHostMarkup();
ReactReconciler.unmountComponent(prevChild, false);
}
// The child must be instantiated before it's mounted.
nextChildren[childName] = this.instantiateReactComponent(nextElement, true);
}
}
}
if (!!prevChildren) {
// Unmount children that are no longer present.
const prevChildrenKeys = Object.keys(prevChildren);
for (let i = 0; i < prevChildrenKeys.length; ++i) {
const childName = prevChildrenKeys[i];
if (!(nextChildren && nextChildren.hasOwnProperty(childName))) {
const prevChild = prevChildren[childName];
removedMarkups[childName] = prevChild.getHostMarkup();
ReactReconciler.unmountComponent(prevChild, false);
}
}
}
return nextChildren;
}