mirror of
https://github.com/facebook/react.git
synced 2026-02-26 03:25:25 +00:00
bc753a716e
This doesn't actually need to share any state because it goes through the instance to the fiber structure. Since Fabric is on the same version as RN, calling it on either renderer works.
105 lines
3.8 KiB
JavaScript
105 lines
3.8 KiB
JavaScript
/**
|
|
* Copyright (c) 2015-present, Facebook, Inc.
|
|
*
|
|
* This source code is licensed under the MIT license found in the
|
|
* LICENSE file in the root directory of this source tree.
|
|
*
|
|
* @flow
|
|
*/
|
|
|
|
import type {Fiber} from 'react-reconciler/src/ReactFiber';
|
|
|
|
import * as ReactInstanceMap from 'shared/ReactInstanceMap';
|
|
import {ReactCurrentOwner} from 'shared/ReactGlobalSharedState';
|
|
import getComponentName from 'shared/getComponentName';
|
|
import invariant from 'fbjs/lib/invariant';
|
|
import warning from 'fbjs/lib/warning';
|
|
|
|
let findHostInstance = function(fiber: Fiber): any {
|
|
return null;
|
|
};
|
|
|
|
export function injectFindHostInstance(impl: (fiber: Fiber) => any) {
|
|
findHostInstance = impl;
|
|
}
|
|
|
|
/**
|
|
* ReactNative vs ReactWeb
|
|
* -----------------------
|
|
* React treats some pieces of data opaquely. This means that the information
|
|
* is first class (it can be passed around), but cannot be inspected. This
|
|
* allows us to build infrastructure that reasons about resources, without
|
|
* making assumptions about the nature of those resources, and this allows that
|
|
* infra to be shared across multiple platforms, where the resources are very
|
|
* different. General infra (such as `ReactMultiChild`) reasons opaquely about
|
|
* the data, but platform specific code (such as `ReactNativeBaseComponent`) can
|
|
* make assumptions about the data.
|
|
*
|
|
*
|
|
* `rootNodeID`, uniquely identifies a position in the generated native view
|
|
* tree. Many layers of composite components (created with `React.createClass`)
|
|
* can all share the same `rootNodeID`.
|
|
*
|
|
* `nodeHandle`: A sufficiently unambiguous way to refer to a lower level
|
|
* resource (dom node, native view etc). The `rootNodeID` is sufficient for web
|
|
* `nodeHandle`s, because the position in a tree is always enough to uniquely
|
|
* identify a DOM node (we never have nodes in some bank outside of the
|
|
* document). The same would be true for `ReactNative`, but we must maintain a
|
|
* mapping that we can send efficiently serializable
|
|
* strings across native boundaries.
|
|
*
|
|
* Opaque name TodaysWebReact FutureWebWorkerReact ReactNative
|
|
* ----------------------------------------------------------------------------
|
|
* nodeHandle N/A rootNodeID tag
|
|
*/
|
|
|
|
// TODO (bvaughn) Rename the findNodeHandle module to something more descriptive
|
|
// eg findInternalHostInstance. This will reduce the likelihood of someone
|
|
// accidentally deep-requiring this version.
|
|
function findNodeHandle(componentOrHandle: any): any {
|
|
if (__DEV__) {
|
|
const owner = ReactCurrentOwner.current;
|
|
if (owner !== null && owner.stateNode !== null) {
|
|
warning(
|
|
owner.stateNode._warnedAboutRefsInRender,
|
|
'%s is accessing findNodeHandle inside its render(). ' +
|
|
'render() should be a pure function of props and state. It should ' +
|
|
'never access something that requires stale data from the previous ' +
|
|
'render, such as refs. Move this logic to componentDidMount and ' +
|
|
'componentDidUpdate instead.',
|
|
getComponentName(owner) || 'A component',
|
|
);
|
|
|
|
owner.stateNode._warnedAboutRefsInRender = true;
|
|
}
|
|
}
|
|
if (componentOrHandle == null) {
|
|
return null;
|
|
}
|
|
if (typeof componentOrHandle === 'number') {
|
|
// Already a node handle
|
|
return componentOrHandle;
|
|
}
|
|
|
|
const component = componentOrHandle;
|
|
|
|
// TODO (sophiebits): Wrap iOS native components in a composite wrapper, then
|
|
// ReactInstanceMap.get here will always succeed for mounted components
|
|
const internalInstance: Fiber = ReactInstanceMap.get(component);
|
|
if (internalInstance) {
|
|
return findHostInstance(internalInstance);
|
|
} else {
|
|
if (component) {
|
|
return component;
|
|
} else {
|
|
invariant(
|
|
false,
|
|
'findNodeHandle(...): Unable to find node handle for unmounted ' +
|
|
'component.',
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
export default findNodeHandle;
|