mirror of
https://github.com/facebook/react.git
synced 2025-11-01 09:12:30 +00:00
824 lines
25 KiB
JavaScript
824 lines
25 KiB
JavaScript
/**
|
||
* Copyright (c) Facebook, Inc. and its affiliates.
|
||
*
|
||
* 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 {ReactElement} from 'shared/ReactElementType';
|
||
import type {
|
||
ReactFragment,
|
||
ReactPortal,
|
||
ReactFundamentalComponent,
|
||
ReactScope,
|
||
} from 'shared/ReactTypes';
|
||
import type {Fiber} from './ReactInternalTypes';
|
||
import type {RootTag} from './ReactRootTags';
|
||
import type {WorkTag} from './ReactWorkTags';
|
||
import type {TypeOfMode} from './ReactTypeOfMode';
|
||
import type {ExpirationTime} from './ReactFiberExpirationTime.new';
|
||
import type {SuspenseInstance} from './ReactFiberHostConfig';
|
||
|
||
import invariant from 'shared/invariant';
|
||
import {
|
||
enableProfilerTimer,
|
||
enableFundamentalAPI,
|
||
enableScopeAPI,
|
||
enableBlocksAPI,
|
||
throwEarlyForMysteriousError,
|
||
} from 'shared/ReactFeatureFlags';
|
||
import {NoEffect, Placement} from './ReactSideEffectTags';
|
||
import {ConcurrentRoot, BlockingRoot} from './ReactRootTags';
|
||
import {
|
||
IndeterminateComponent,
|
||
ClassComponent,
|
||
HostRoot,
|
||
HostComponent,
|
||
HostText,
|
||
HostPortal,
|
||
ForwardRef,
|
||
Fragment,
|
||
Mode,
|
||
ContextProvider,
|
||
ContextConsumer,
|
||
Profiler,
|
||
SuspenseComponent,
|
||
SuspenseListComponent,
|
||
DehydratedFragment,
|
||
FunctionComponent,
|
||
MemoComponent,
|
||
SimpleMemoComponent,
|
||
LazyComponent,
|
||
FundamentalComponent,
|
||
ScopeComponent,
|
||
Block,
|
||
} from './ReactWorkTags';
|
||
import getComponentName from 'shared/getComponentName';
|
||
|
||
import {isDevToolsPresent} from './ReactFiberDevToolsHook.new';
|
||
import {
|
||
resolveClassForHotReloading,
|
||
resolveFunctionForHotReloading,
|
||
resolveForwardRefForHotReloading,
|
||
} from './ReactFiberHotReloading.new';
|
||
import {NoWork} from './ReactFiberExpirationTime.new';
|
||
import {
|
||
NoMode,
|
||
ConcurrentMode,
|
||
DebugTracingMode,
|
||
ProfileMode,
|
||
StrictMode,
|
||
BlockingMode,
|
||
} from './ReactTypeOfMode';
|
||
import {
|
||
REACT_FORWARD_REF_TYPE,
|
||
REACT_FRAGMENT_TYPE,
|
||
REACT_DEBUG_TRACING_MODE_TYPE,
|
||
REACT_STRICT_MODE_TYPE,
|
||
REACT_PROFILER_TYPE,
|
||
REACT_PROVIDER_TYPE,
|
||
REACT_CONTEXT_TYPE,
|
||
REACT_SUSPENSE_TYPE,
|
||
REACT_SUSPENSE_LIST_TYPE,
|
||
REACT_MEMO_TYPE,
|
||
REACT_LAZY_TYPE,
|
||
REACT_FUNDAMENTAL_TYPE,
|
||
REACT_SCOPE_TYPE,
|
||
REACT_BLOCK_TYPE,
|
||
} from 'shared/ReactSymbols';
|
||
|
||
export type {Fiber};
|
||
|
||
let hasBadMapPolyfill;
|
||
|
||
if (__DEV__) {
|
||
hasBadMapPolyfill = false;
|
||
try {
|
||
const nonExtensibleObject = Object.preventExtensions({});
|
||
/* eslint-disable no-new */
|
||
new Map([[nonExtensibleObject, null]]);
|
||
new Set([nonExtensibleObject]);
|
||
/* eslint-enable no-new */
|
||
} catch (e) {
|
||
// TODO: Consider warning about bad polyfills
|
||
hasBadMapPolyfill = true;
|
||
}
|
||
}
|
||
|
||
let debugCounter = 1;
|
||
|
||
function FiberNode(
|
||
tag: WorkTag,
|
||
pendingProps: mixed,
|
||
key: null | string,
|
||
mode: TypeOfMode,
|
||
) {
|
||
// Instance
|
||
this.tag = tag;
|
||
this.key = key;
|
||
this.elementType = null;
|
||
this.type = null;
|
||
this.stateNode = null;
|
||
|
||
// Fiber
|
||
this.return = null;
|
||
this.child = null;
|
||
this.sibling = null;
|
||
this.index = 0;
|
||
|
||
this.ref = null;
|
||
|
||
this.pendingProps = pendingProps;
|
||
this.memoizedProps = null;
|
||
this.updateQueue = null;
|
||
this.memoizedState = null;
|
||
this.dependencies = null;
|
||
|
||
this.mode = mode;
|
||
|
||
// Effects
|
||
this.effectTag = NoEffect;
|
||
this.nextEffect = null;
|
||
|
||
this.firstEffect = null;
|
||
this.lastEffect = null;
|
||
|
||
this.expirationTime = NoWork;
|
||
this.childExpirationTime = NoWork;
|
||
|
||
this.alternate = null;
|
||
|
||
if (enableProfilerTimer) {
|
||
// Note: The following is done to avoid a v8 performance cliff.
|
||
//
|
||
// Initializing the fields below to smis and later updating them with
|
||
// double values will cause Fibers to end up having separate shapes.
|
||
// This behavior/bug has something to do with Object.preventExtension().
|
||
// Fortunately this only impacts DEV builds.
|
||
// Unfortunately it makes React unusably slow for some applications.
|
||
// To work around this, initialize the fields below with doubles.
|
||
//
|
||
// Learn more about this here:
|
||
// https://github.com/facebook/react/issues/14365
|
||
// https://bugs.chromium.org/p/v8/issues/detail?id=8538
|
||
this.actualDuration = Number.NaN;
|
||
this.actualStartTime = Number.NaN;
|
||
this.selfBaseDuration = Number.NaN;
|
||
this.treeBaseDuration = Number.NaN;
|
||
|
||
// It's okay to replace the initial doubles with smis after initialization.
|
||
// This won't trigger the performance cliff mentioned above,
|
||
// and it simplifies other profiler code (including DevTools).
|
||
this.actualDuration = 0;
|
||
this.actualStartTime = -1;
|
||
this.selfBaseDuration = 0;
|
||
this.treeBaseDuration = 0;
|
||
}
|
||
|
||
if (__DEV__) {
|
||
// This isn't directly used but is handy for debugging internals:
|
||
this._debugID = debugCounter++;
|
||
this._debugSource = null;
|
||
this._debugOwner = null;
|
||
this._debugNeedsRemount = false;
|
||
this._debugHookTypes = null;
|
||
if (!hasBadMapPolyfill && typeof Object.preventExtensions === 'function') {
|
||
Object.preventExtensions(this);
|
||
}
|
||
}
|
||
}
|
||
|
||
// This is a constructor function, rather than a POJO constructor, still
|
||
// please ensure we do the following:
|
||
// 1) Nobody should add any instance methods on this. Instance methods can be
|
||
// more difficult to predict when they get optimized and they are almost
|
||
// never inlined properly in static compilers.
|
||
// 2) Nobody should rely on `instanceof Fiber` for type testing. We should
|
||
// always know when it is a fiber.
|
||
// 3) We might want to experiment with using numeric keys since they are easier
|
||
// to optimize in a non-JIT environment.
|
||
// 4) We can easily go from a constructor to a createFiber object literal if that
|
||
// is faster.
|
||
// 5) It should be easy to port this to a C struct and keep a C implementation
|
||
// compatible.
|
||
const createFiber = function(
|
||
tag: WorkTag,
|
||
pendingProps: mixed,
|
||
key: null | string,
|
||
mode: TypeOfMode,
|
||
): Fiber {
|
||
// $FlowFixMe: the shapes are exact here but Flow doesn't like constructors
|
||
return new FiberNode(tag, pendingProps, key, mode);
|
||
};
|
||
|
||
function shouldConstruct(Component: Function) {
|
||
const prototype = Component.prototype;
|
||
return !!(prototype && prototype.isReactComponent);
|
||
}
|
||
|
||
export function isSimpleFunctionComponent(type: any) {
|
||
return (
|
||
typeof type === 'function' &&
|
||
!shouldConstruct(type) &&
|
||
type.defaultProps === undefined
|
||
);
|
||
}
|
||
|
||
export function resolveLazyComponentTag(Component: Function): WorkTag {
|
||
if (typeof Component === 'function') {
|
||
return shouldConstruct(Component) ? ClassComponent : FunctionComponent;
|
||
} else if (Component !== undefined && Component !== null) {
|
||
const $$typeof = Component.$$typeof;
|
||
if ($$typeof === REACT_FORWARD_REF_TYPE) {
|
||
return ForwardRef;
|
||
}
|
||
if ($$typeof === REACT_MEMO_TYPE) {
|
||
return MemoComponent;
|
||
}
|
||
if (enableBlocksAPI) {
|
||
if ($$typeof === REACT_BLOCK_TYPE) {
|
||
return Block;
|
||
}
|
||
}
|
||
}
|
||
return IndeterminateComponent;
|
||
}
|
||
|
||
// This is used to create an alternate fiber to do work on.
|
||
export function createWorkInProgress(current: Fiber, pendingProps: any): Fiber {
|
||
let workInProgress = current.alternate;
|
||
if (workInProgress === null) {
|
||
// We use a double buffering pooling technique because we know that we'll
|
||
// only ever need at most two versions of a tree. We pool the "other" unused
|
||
// node that we're free to reuse. This is lazily created to avoid allocating
|
||
// extra objects for things that are never updated. It also allow us to
|
||
// reclaim the extra memory if needed.
|
||
workInProgress = createFiber(
|
||
current.tag,
|
||
pendingProps,
|
||
current.key,
|
||
current.mode,
|
||
);
|
||
workInProgress.elementType = current.elementType;
|
||
workInProgress.type = current.type;
|
||
workInProgress.stateNode = current.stateNode;
|
||
|
||
if (__DEV__) {
|
||
// DEV-only fields
|
||
workInProgress._debugID = current._debugID;
|
||
workInProgress._debugSource = current._debugSource;
|
||
workInProgress._debugOwner = current._debugOwner;
|
||
workInProgress._debugHookTypes = current._debugHookTypes;
|
||
}
|
||
|
||
workInProgress.alternate = current;
|
||
current.alternate = workInProgress;
|
||
} else {
|
||
workInProgress.pendingProps = pendingProps;
|
||
|
||
// We already have an alternate.
|
||
// Reset the effect tag.
|
||
workInProgress.effectTag = NoEffect;
|
||
|
||
// The effect list is no longer valid.
|
||
workInProgress.nextEffect = null;
|
||
workInProgress.firstEffect = null;
|
||
workInProgress.lastEffect = null;
|
||
|
||
if (enableProfilerTimer) {
|
||
// We intentionally reset, rather than copy, actualDuration & actualStartTime.
|
||
// This prevents time from endlessly accumulating in new commits.
|
||
// This has the downside of resetting values for different priority renders,
|
||
// But works for yielding (the common case) and should support resuming.
|
||
workInProgress.actualDuration = 0;
|
||
workInProgress.actualStartTime = -1;
|
||
}
|
||
}
|
||
|
||
if (throwEarlyForMysteriousError) {
|
||
// Trying to debug a mysterious internal-only production failure.
|
||
// See D20130868 and t62461245.
|
||
// This is only on for RN FB builds.
|
||
if (current == null) {
|
||
throw Error('current is ' + current + " but it can't be");
|
||
}
|
||
if (workInProgress == null) {
|
||
throw Error('workInProgress is ' + workInProgress + " but it can't be");
|
||
}
|
||
}
|
||
|
||
workInProgress.childExpirationTime = current.childExpirationTime;
|
||
workInProgress.expirationTime = current.expirationTime;
|
||
|
||
workInProgress.child = current.child;
|
||
workInProgress.memoizedProps = current.memoizedProps;
|
||
workInProgress.memoizedState = current.memoizedState;
|
||
workInProgress.updateQueue = current.updateQueue;
|
||
|
||
// Clone the dependencies object. This is mutated during the render phase, so
|
||
// it cannot be shared with the current fiber.
|
||
const currentDependencies = current.dependencies;
|
||
workInProgress.dependencies =
|
||
currentDependencies === null
|
||
? null
|
||
: {
|
||
expirationTime: currentDependencies.expirationTime,
|
||
firstContext: currentDependencies.firstContext,
|
||
responders: currentDependencies.responders,
|
||
};
|
||
|
||
// These will be overridden during the parent's reconciliation
|
||
workInProgress.sibling = current.sibling;
|
||
workInProgress.index = current.index;
|
||
workInProgress.ref = current.ref;
|
||
|
||
if (enableProfilerTimer) {
|
||
workInProgress.selfBaseDuration = current.selfBaseDuration;
|
||
workInProgress.treeBaseDuration = current.treeBaseDuration;
|
||
}
|
||
|
||
if (__DEV__) {
|
||
workInProgress._debugNeedsRemount = current._debugNeedsRemount;
|
||
switch (workInProgress.tag) {
|
||
case IndeterminateComponent:
|
||
case FunctionComponent:
|
||
case SimpleMemoComponent:
|
||
workInProgress.type = resolveFunctionForHotReloading(current.type);
|
||
break;
|
||
case ClassComponent:
|
||
workInProgress.type = resolveClassForHotReloading(current.type);
|
||
break;
|
||
case ForwardRef:
|
||
workInProgress.type = resolveForwardRefForHotReloading(current.type);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
|
||
return workInProgress;
|
||
}
|
||
|
||
// Used to reuse a Fiber for a second pass.
|
||
export function resetWorkInProgress(
|
||
workInProgress: Fiber,
|
||
renderExpirationTime: ExpirationTime,
|
||
) {
|
||
// This resets the Fiber to what createFiber or createWorkInProgress would
|
||
// have set the values to before during the first pass. Ideally this wouldn't
|
||
// be necessary but unfortunately many code paths reads from the workInProgress
|
||
// when they should be reading from current and writing to workInProgress.
|
||
|
||
// We assume pendingProps, index, key, ref, return are still untouched to
|
||
// avoid doing another reconciliation.
|
||
|
||
// Reset the effect tag but keep any Placement tags, since that's something
|
||
// that child fiber is setting, not the reconciliation.
|
||
workInProgress.effectTag &= Placement;
|
||
|
||
// The effect list is no longer valid.
|
||
workInProgress.nextEffect = null;
|
||
workInProgress.firstEffect = null;
|
||
workInProgress.lastEffect = null;
|
||
|
||
const current = workInProgress.alternate;
|
||
if (current === null) {
|
||
// Reset to createFiber's initial values.
|
||
workInProgress.childExpirationTime = NoWork;
|
||
workInProgress.expirationTime = renderExpirationTime;
|
||
|
||
workInProgress.child = null;
|
||
workInProgress.memoizedProps = null;
|
||
workInProgress.memoizedState = null;
|
||
workInProgress.updateQueue = null;
|
||
|
||
workInProgress.dependencies = null;
|
||
|
||
workInProgress.stateNode = null;
|
||
|
||
if (enableProfilerTimer) {
|
||
// Note: We don't reset the actualTime counts. It's useful to accumulate
|
||
// actual time across multiple render passes.
|
||
workInProgress.selfBaseDuration = 0;
|
||
workInProgress.treeBaseDuration = 0;
|
||
}
|
||
} else {
|
||
// Reset to the cloned values that createWorkInProgress would've.
|
||
workInProgress.childExpirationTime = current.childExpirationTime;
|
||
workInProgress.expirationTime = current.expirationTime;
|
||
|
||
workInProgress.child = current.child;
|
||
workInProgress.memoizedProps = current.memoizedProps;
|
||
workInProgress.memoizedState = current.memoizedState;
|
||
workInProgress.updateQueue = current.updateQueue;
|
||
|
||
// Clone the dependencies object. This is mutated during the render phase, so
|
||
// it cannot be shared with the current fiber.
|
||
const currentDependencies = current.dependencies;
|
||
workInProgress.dependencies =
|
||
currentDependencies === null
|
||
? null
|
||
: {
|
||
expirationTime: currentDependencies.expirationTime,
|
||
firstContext: currentDependencies.firstContext,
|
||
responders: currentDependencies.responders,
|
||
};
|
||
|
||
if (enableProfilerTimer) {
|
||
// Note: We don't reset the actualTime counts. It's useful to accumulate
|
||
// actual time across multiple render passes.
|
||
workInProgress.selfBaseDuration = current.selfBaseDuration;
|
||
workInProgress.treeBaseDuration = current.treeBaseDuration;
|
||
}
|
||
}
|
||
|
||
return workInProgress;
|
||
}
|
||
|
||
export function createHostRootFiber(tag: RootTag): Fiber {
|
||
let mode;
|
||
if (tag === ConcurrentRoot) {
|
||
mode = ConcurrentMode | BlockingMode | StrictMode;
|
||
} else if (tag === BlockingRoot) {
|
||
mode = BlockingMode | StrictMode;
|
||
} else {
|
||
mode = NoMode;
|
||
}
|
||
|
||
if (enableProfilerTimer && isDevToolsPresent) {
|
||
// Always collect profile timings when DevTools are present.
|
||
// This enables DevTools to start capturing timing at any point–
|
||
// Without some nodes in the tree having empty base times.
|
||
mode |= ProfileMode;
|
||
}
|
||
|
||
return createFiber(HostRoot, null, null, mode);
|
||
}
|
||
|
||
export function createFiberFromTypeAndProps(
|
||
type: any, // React$ElementType
|
||
key: null | string,
|
||
pendingProps: any,
|
||
owner: null | Fiber,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
): Fiber {
|
||
let fiberTag = IndeterminateComponent;
|
||
// The resolved type is set if we know what the final type will be. I.e. it's not lazy.
|
||
let resolvedType = type;
|
||
if (typeof type === 'function') {
|
||
if (shouldConstruct(type)) {
|
||
fiberTag = ClassComponent;
|
||
if (__DEV__) {
|
||
resolvedType = resolveClassForHotReloading(resolvedType);
|
||
}
|
||
} else {
|
||
if (__DEV__) {
|
||
resolvedType = resolveFunctionForHotReloading(resolvedType);
|
||
}
|
||
}
|
||
} else if (typeof type === 'string') {
|
||
fiberTag = HostComponent;
|
||
} else {
|
||
getTag: switch (type) {
|
||
case REACT_FRAGMENT_TYPE:
|
||
return createFiberFromFragment(
|
||
pendingProps.children,
|
||
mode,
|
||
expirationTime,
|
||
key,
|
||
);
|
||
case REACT_DEBUG_TRACING_MODE_TYPE:
|
||
fiberTag = Mode;
|
||
mode |= DebugTracingMode;
|
||
break;
|
||
case REACT_STRICT_MODE_TYPE:
|
||
fiberTag = Mode;
|
||
mode |= StrictMode;
|
||
break;
|
||
case REACT_PROFILER_TYPE:
|
||
return createFiberFromProfiler(pendingProps, mode, expirationTime, key);
|
||
case REACT_SUSPENSE_TYPE:
|
||
return createFiberFromSuspense(pendingProps, mode, expirationTime, key);
|
||
case REACT_SUSPENSE_LIST_TYPE:
|
||
return createFiberFromSuspenseList(
|
||
pendingProps,
|
||
mode,
|
||
expirationTime,
|
||
key,
|
||
);
|
||
default: {
|
||
if (typeof type === 'object' && type !== null) {
|
||
switch (type.$$typeof) {
|
||
case REACT_PROVIDER_TYPE:
|
||
fiberTag = ContextProvider;
|
||
break getTag;
|
||
case REACT_CONTEXT_TYPE:
|
||
// This is a consumer
|
||
fiberTag = ContextConsumer;
|
||
break getTag;
|
||
case REACT_FORWARD_REF_TYPE:
|
||
fiberTag = ForwardRef;
|
||
if (__DEV__) {
|
||
resolvedType = resolveForwardRefForHotReloading(resolvedType);
|
||
}
|
||
break getTag;
|
||
case REACT_MEMO_TYPE:
|
||
fiberTag = MemoComponent;
|
||
break getTag;
|
||
case REACT_LAZY_TYPE:
|
||
fiberTag = LazyComponent;
|
||
resolvedType = null;
|
||
break getTag;
|
||
case REACT_BLOCK_TYPE:
|
||
fiberTag = Block;
|
||
break getTag;
|
||
case REACT_FUNDAMENTAL_TYPE:
|
||
if (enableFundamentalAPI) {
|
||
return createFiberFromFundamental(
|
||
type,
|
||
pendingProps,
|
||
mode,
|
||
expirationTime,
|
||
key,
|
||
);
|
||
}
|
||
break;
|
||
case REACT_SCOPE_TYPE:
|
||
if (enableScopeAPI) {
|
||
return createFiberFromScope(
|
||
type,
|
||
pendingProps,
|
||
mode,
|
||
expirationTime,
|
||
key,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
let info = '';
|
||
if (__DEV__) {
|
||
if (
|
||
type === undefined ||
|
||
(typeof type === 'object' &&
|
||
type !== null &&
|
||
Object.keys(type).length === 0)
|
||
) {
|
||
info +=
|
||
' You likely forgot to export your component from the file ' +
|
||
"it's defined in, or you might have mixed up default and " +
|
||
'named imports.';
|
||
}
|
||
const ownerName = owner ? getComponentName(owner.type) : null;
|
||
if (ownerName) {
|
||
info += '\n\nCheck the render method of `' + ownerName + '`.';
|
||
}
|
||
}
|
||
invariant(
|
||
false,
|
||
'Element type is invalid: expected a string (for built-in ' +
|
||
'components) or a class/function (for composite components) ' +
|
||
'but got: %s.%s',
|
||
type == null ? type : typeof type,
|
||
info,
|
||
);
|
||
}
|
||
}
|
||
}
|
||
|
||
const fiber = createFiber(fiberTag, pendingProps, key, mode);
|
||
fiber.elementType = type;
|
||
fiber.type = resolvedType;
|
||
fiber.expirationTime = expirationTime;
|
||
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromElement(
|
||
element: ReactElement,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
): Fiber {
|
||
let owner = null;
|
||
if (__DEV__) {
|
||
owner = element._owner;
|
||
}
|
||
const type = element.type;
|
||
const key = element.key;
|
||
const pendingProps = element.props;
|
||
const fiber = createFiberFromTypeAndProps(
|
||
type,
|
||
key,
|
||
pendingProps,
|
||
owner,
|
||
mode,
|
||
expirationTime,
|
||
);
|
||
if (__DEV__) {
|
||
fiber._debugSource = element._source;
|
||
fiber._debugOwner = element._owner;
|
||
}
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromFragment(
|
||
elements: ReactFragment,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
): Fiber {
|
||
const fiber = createFiber(Fragment, elements, key, mode);
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromFundamental(
|
||
fundamentalComponent: ReactFundamentalComponent<any, any>,
|
||
pendingProps: any,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
): Fiber {
|
||
const fiber = createFiber(FundamentalComponent, pendingProps, key, mode);
|
||
fiber.elementType = fundamentalComponent;
|
||
fiber.type = fundamentalComponent;
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
function createFiberFromScope(
|
||
scope: ReactScope,
|
||
pendingProps: any,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
) {
|
||
const fiber = createFiber(ScopeComponent, pendingProps, key, mode);
|
||
fiber.type = scope;
|
||
fiber.elementType = scope;
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
function createFiberFromProfiler(
|
||
pendingProps: any,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
): Fiber {
|
||
if (__DEV__) {
|
||
if (typeof pendingProps.id !== 'string') {
|
||
console.error('Profiler must specify an "id" as a prop');
|
||
}
|
||
}
|
||
|
||
const fiber = createFiber(Profiler, pendingProps, key, mode | ProfileMode);
|
||
// TODO: The Profiler fiber shouldn't have a type. It has a tag.
|
||
fiber.elementType = REACT_PROFILER_TYPE;
|
||
fiber.type = REACT_PROFILER_TYPE;
|
||
fiber.expirationTime = expirationTime;
|
||
|
||
if (enableProfilerTimer) {
|
||
fiber.stateNode = {
|
||
effectDuration: 0,
|
||
passiveEffectDuration: 0,
|
||
};
|
||
}
|
||
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromSuspense(
|
||
pendingProps: any,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
) {
|
||
const fiber = createFiber(SuspenseComponent, pendingProps, key, mode);
|
||
|
||
// TODO: The SuspenseComponent fiber shouldn't have a type. It has a tag.
|
||
// This needs to be fixed in getComponentName so that it relies on the tag
|
||
// instead.
|
||
fiber.type = REACT_SUSPENSE_TYPE;
|
||
fiber.elementType = REACT_SUSPENSE_TYPE;
|
||
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromSuspenseList(
|
||
pendingProps: any,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
key: null | string,
|
||
) {
|
||
const fiber = createFiber(SuspenseListComponent, pendingProps, key, mode);
|
||
if (__DEV__) {
|
||
// TODO: The SuspenseListComponent fiber shouldn't have a type. It has a tag.
|
||
// This needs to be fixed in getComponentName so that it relies on the tag
|
||
// instead.
|
||
fiber.type = REACT_SUSPENSE_LIST_TYPE;
|
||
}
|
||
fiber.elementType = REACT_SUSPENSE_LIST_TYPE;
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromText(
|
||
content: string,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
): Fiber {
|
||
const fiber = createFiber(HostText, content, null, mode);
|
||
fiber.expirationTime = expirationTime;
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromHostInstanceForDeletion(): Fiber {
|
||
const fiber = createFiber(HostComponent, null, null, NoMode);
|
||
// TODO: These should not need a type.
|
||
fiber.elementType = 'DELETED';
|
||
fiber.type = 'DELETED';
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromDehydratedFragment(
|
||
dehydratedNode: SuspenseInstance,
|
||
): Fiber {
|
||
const fiber = createFiber(DehydratedFragment, null, null, NoMode);
|
||
fiber.stateNode = dehydratedNode;
|
||
return fiber;
|
||
}
|
||
|
||
export function createFiberFromPortal(
|
||
portal: ReactPortal,
|
||
mode: TypeOfMode,
|
||
expirationTime: ExpirationTime,
|
||
): Fiber {
|
||
const pendingProps = portal.children !== null ? portal.children : [];
|
||
const fiber = createFiber(HostPortal, pendingProps, portal.key, mode);
|
||
fiber.expirationTime = expirationTime;
|
||
fiber.stateNode = {
|
||
containerInfo: portal.containerInfo,
|
||
pendingChildren: null, // Used by persistent updates
|
||
implementation: portal.implementation,
|
||
};
|
||
return fiber;
|
||
}
|
||
|
||
// Used for stashing WIP properties to replay failed work in DEV.
|
||
export function assignFiberPropertiesInDEV(
|
||
target: Fiber | null,
|
||
source: Fiber,
|
||
): Fiber {
|
||
if (target === null) {
|
||
// This Fiber's initial properties will always be overwritten.
|
||
// We only use a Fiber to ensure the same hidden class so DEV isn't slow.
|
||
target = createFiber(IndeterminateComponent, null, null, NoMode);
|
||
}
|
||
|
||
// This is intentionally written as a list of all properties.
|
||
// We tried to use Object.assign() instead but this is called in
|
||
// the hottest path, and Object.assign() was too slow:
|
||
// https://github.com/facebook/react/issues/12502
|
||
// This code is DEV-only so size is not a concern.
|
||
|
||
target.tag = source.tag;
|
||
target.key = source.key;
|
||
target.elementType = source.elementType;
|
||
target.type = source.type;
|
||
target.stateNode = source.stateNode;
|
||
target.return = source.return;
|
||
target.child = source.child;
|
||
target.sibling = source.sibling;
|
||
target.index = source.index;
|
||
target.ref = source.ref;
|
||
target.pendingProps = source.pendingProps;
|
||
target.memoizedProps = source.memoizedProps;
|
||
target.updateQueue = source.updateQueue;
|
||
target.memoizedState = source.memoizedState;
|
||
target.dependencies = source.dependencies;
|
||
target.mode = source.mode;
|
||
target.effectTag = source.effectTag;
|
||
target.nextEffect = source.nextEffect;
|
||
target.firstEffect = source.firstEffect;
|
||
target.lastEffect = source.lastEffect;
|
||
target.expirationTime = source.expirationTime;
|
||
target.childExpirationTime = source.childExpirationTime;
|
||
target.alternate = source.alternate;
|
||
if (enableProfilerTimer) {
|
||
target.actualDuration = source.actualDuration;
|
||
target.actualStartTime = source.actualStartTime;
|
||
target.selfBaseDuration = source.selfBaseDuration;
|
||
target.treeBaseDuration = source.treeBaseDuration;
|
||
}
|
||
target._debugID = source._debugID;
|
||
target._debugSource = source._debugSource;
|
||
target._debugOwner = source._debugOwner;
|
||
target._debugNeedsRemount = source._debugNeedsRemount;
|
||
target._debugHookTypes = source._debugHookTypes;
|
||
return target;
|
||
}
|