code
stringlengths
24
2.07M
docstring
stringlengths
25
85.3k
func_name
stringlengths
1
92
language
stringclasses
1 value
repo
stringlengths
5
64
path
stringlengths
4
172
url
stringlengths
44
218
license
stringclasses
7 values
function writeEndPendingSuspenseBoundary(destination, responseState) { return writeChunkAndReturn(destination, endSuspenseBoundary); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeEndPendingSuspenseBoundary
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeEndClientRenderedSuspenseBoundary(destination, responseState) { return writeChunkAndReturn(destination, endSuspenseBoundary); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeEndClientRenderedSuspenseBoundary
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeStartSegment(destination, responseState, formatContext, id) { switch (formatContext.insertionMode) { case ROOT_HTML_MODE: case HTML_MODE: { writeChunk(destination, startSegmentHTML); writeChunk(destination, responseState.seg...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeStartSegment
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeEndSegment(destination, formatContext) { switch (formatContext.insertionMode) { case ROOT_HTML_MODE: case HTML_MODE: { return writeChunkAndReturn(destination, endSegmentHTML); } case SVG_MODE: { ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeEndSegment
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeCompletedSegmentInstruction(destination, responseState, contentSegmentID) { writeChunk(destination, responseState.startInlineScript); if (!responseState.sentCompleteSegmentFunction) { responseState.sentCompleteSegmentFunction = true; writeChunk(d...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeCompletedSegmentInstruction
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeCompletedBoundaryInstruction(destination, responseState, boundaryID, contentSegmentID) { writeChunk(destination, responseState.startInlineScript); if (!responseState.sentCompleteBoundaryFunction) { responseState.sentCompleteBoundaryFunction = true; ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeCompletedBoundaryInstruction
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function writeClientRenderBoundaryInstruction(destination, responseState, boundaryID, errorDigest, errorMessage, errorComponentStack) { writeChunk(destination, responseState.startInlineScript); if (!responseState.sentClientRenderFunction) { responseState.sentClientRenderFunct...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
writeClientRenderBoundaryInstruction
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function escapeJSStringsForInstructionScripts(input) { var escaped = JSON.stringify(input); return escaped.replace(regexForJSStringsInScripts, function(match) { switch (match) { case "<": return "\\u003c"; case "\u2028":...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
escapeJSStringsForInstructionScripts
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getIteratorFn(maybeIterable) { if (maybeIterable === null || typeof maybeIterable !== "object") { return null; } var maybeIterator = MAYBE_ITERATOR_SYMBOL && maybeIterable[MAYBE_ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]; if (...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getIteratorFn
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getWrappedName(outerType, innerType, wrapperName) { var displayName = outerType.displayName; if (displayName) { return displayName; } var functionName = innerType.displayName || innerType.name || ""; return functionName !== "...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getWrappedName
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getContextName(type) { return type.displayName || "Context"; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getContextName
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getComponentNameFromType(type) { if (type == null) { return null; } { if (typeof type.tag === "number") { error("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getComponentNameFromType
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function disableLogs() { { if (disabledDepth === 0) { prevLog = console.log; prevInfo = console.info; prevWarn = console.warn; prevError = console.error; prevGroup = console.group; p...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
disableLogs
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function reenableLogs() { { disabledDepth--; if (disabledDepth === 0) { var props = { configurable: true, enumerable: true, writable: true }; Object.definePrope...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
reenableLogs
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function describeBuiltInComponentFrame(name, source, ownerFn) { { if (prefix === void 0) { try { throw Error(); } catch (x) { var match = x.stack.trim().match(/\n( *(at )?)/); prefix = match && ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
describeBuiltInComponentFrame
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function describeNativeComponentFrame(fn, construct) { if (!fn || reentry) { return ""; } { var frame = componentFrameCache.get(fn); if (frame !== void 0) { return frame; } } ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
describeNativeComponentFrame
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
Fake = function() { throw Error(); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
Fake
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function describeClassComponentFrame(ctor, source, ownerFn) { { return describeNativeComponentFrame(ctor, true); } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
describeClassComponentFrame
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function describeFunctionComponentFrame(fn, source, ownerFn) { { return describeNativeComponentFrame(fn, false); } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
describeFunctionComponentFrame
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function shouldConstruct(Component) { var prototype = Component.prototype; return !!(prototype && prototype.isReactComponent); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
shouldConstruct
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function describeUnknownElementTypeFrameInDEV(type, source, ownerFn) { if (type == null) { return ""; } if (typeof type === "function") { { return describeNativeComponentFrame(type, shouldConstruct(type)); } ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
describeUnknownElementTypeFrameInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function setCurrentlyValidatingElement(element) { { if (element) { var owner = element._owner; var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null); ReactDebugCurrentFrame.setExtraSt...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
setCurrentlyValidatingElement
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function checkPropTypes(typeSpecs, values, location, componentName, element) { { var has = Function.call.bind(hasOwnProperty); for (var typeSpecName in typeSpecs) { if (has(typeSpecs, typeSpecName)) { var error$1 = void 0; ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
checkPropTypes
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getMaskedContext(type, unmaskedContext) { { var contextTypes = type.contextTypes; if (!contextTypes) { return emptyContextObject; } var context = {}; for (var key in contextTypes) { ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getMaskedContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function processChildContext(instance, type, parentContext, childContextTypes) { { if (typeof instance.getChildContext !== "function") { { var componentName = getComponentNameFromType(type) || "Unknown"; if (!warnedAboutMissingGetCh...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
processChildContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popNode(prev) { { prev.context._currentValue = prev.parentValue; } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popNode
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushNode(next) { { next.context._currentValue = next.value; } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushNode
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popToNearestCommonAncestor(prev, next) { if (prev === next) ; else { popNode(prev); var parentPrev = prev.parent; var parentNext = next.parent; if (parentPrev === null) { if (parentNext...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popToNearestCommonAncestor
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popAllPrevious(prev) { popNode(prev); var parentPrev = prev.parent; if (parentPrev !== null) { popAllPrevious(parentPrev); } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popAllPrevious
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushAllNext(next) { var parentNext = next.parent; if (parentNext !== null) { pushAllNext(parentNext); } pushNode(next); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushAllNext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popPreviousToCommonLevel(prev, next) { popNode(prev); var parentPrev = prev.parent; if (parentPrev === null) { throw new Error("The depth must equal at least at zero before reaching the root. This is a bug in React."); } if (...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popPreviousToCommonLevel
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popNextToCommonLevel(prev, next) { var parentNext = next.parent; if (parentNext === null) { throw new Error("The depth must equal at least at zero before reaching the root. This is a bug in React."); } if (prev.depth === parentNext.depth) ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popNextToCommonLevel
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function switchContext(newSnapshot) { var prev = currentActiveSnapshot; var next = newSnapshot; if (prev !== next) { if (prev === null) { pushAllNext(next); } else if (next === null) { popAllPrevious(prev); ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
switchContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushProvider(context, nextValue) { var prevValue; { prevValue = context._currentValue; context._currentValue = nextValue; { if (context._currentRenderer !== void 0 && context._currentRenderer !== null && context._curr...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushProvider
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popProvider(context) { var prevSnapshot = currentActiveSnapshot; if (prevSnapshot === null) { throw new Error("Tried to pop a Context at the root of the app. This is a bug in React."); } { if (prevSnapshot.context !== conte...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popProvider
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getActiveContext() { return currentActiveSnapshot; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getActiveContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function readContext(context) { var value = context._currentValue; return value; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
readContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function get(key) { return key._reactInternals; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
get
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function set(key, value) { key._reactInternals = value; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
set
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function warnNoop(publicInstance, callerName) { { var _constructor = publicInstance.constructor; var componentName = _constructor && getComponentNameFromType(_constructor) || "ReactClass"; var warningKey = componentName + "." + callerName; if...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
warnNoop
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function applyDerivedStateFromProps(instance, ctor, getDerivedStateFromProps, prevState, nextProps) { var partialState = getDerivedStateFromProps(nextProps, prevState); { warnOnUndefinedDerivedState(ctor, partialState); } var newState = partialStat...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
applyDerivedStateFromProps
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function constructClassInstance(ctor, props, maskedLegacyContext) { var context = emptyContextObject; var contextType = ctor.contextType; { if ("contextType" in ctor) { var isValid = ( // Allow null for conditional declarati...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
constructClassInstance
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function checkClassInstance(instance, ctor, newProps) { { var name = getComponentNameFromType(ctor) || "Component"; var renderPresent = instance.render; if (!renderPresent) { if (ctor.prototype && typeof ctor.prototype.render === "function"...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
checkClassInstance
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function callComponentWillMount(type, instance) { var oldState = instance.state; if (typeof instance.componentWillMount === "function") { { if (instance.componentWillMount.__suppressDeprecationWarning !== true) { var componentName = getCo...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
callComponentWillMount
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function processUpdateQueue(internalInstance, inst, props, maskedLegacyContext) { if (internalInstance.queue !== null && internalInstance.queue.length > 0) { var oldQueue = internalInstance.queue; var oldReplace = internalInstance.replace; internalInstance.q...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
processUpdateQueue
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function mountClassInstance(instance, ctor, newProps, maskedLegacyContext) { { checkClassInstance(instance, ctor, newProps); } var initialState = instance.state !== void 0 ? instance.state : null; instance.updater = classComponentUpdater; ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
mountClassInstance
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getTreeId(context) { var overflow = context.overflow; var idWithLeadingBit = context.id; var id = idWithLeadingBit & ~getLeadingBit(idWithLeadingBit); return id.toString(32) + overflow; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getTreeId
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushTreeContext(baseContext, totalChildren, index) { var baseIdWithLeadingBit = baseContext.id; var baseOverflow = baseContext.overflow; var baseLength = getBitLength(baseIdWithLeadingBit) - 1; var baseId = baseIdWithLeadingBit & ~(1 << baseLength); ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushTreeContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getBitLength(number) { return 32 - clz32(number); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getBitLength
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getLeadingBit(id) { return 1 << getBitLength(id) - 1; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getLeadingBit
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function clz32Fallback(x) { var asUint = x >>> 0; if (asUint === 0) { return 32; } return 31 - (log(asUint) / LN2 | 0) | 0; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
clz32Fallback
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function is(x, y) { return x === y && (x !== 0 || 1 / x === 1 / y) || x !== x && y !== y; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
is
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function resolveCurrentlyRenderingComponent() { if (currentlyRenderingComponent === null) { throw new Error("Invalid hook call. Hooks can only be called inside of the body of a function component. This could happen for one of the following reasons:\n1. You might have mismatching versions o...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
resolveCurrentlyRenderingComponent
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function areHookInputsEqual(nextDeps, prevDeps) { if (prevDeps === null) { { error("%s received a final argument during this render, but not during the previous render. Even though the final argument is optional, its type cannot change between renders.", currentHookNameIn...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
areHookInputsEqual
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createHook() { if (numberOfReRenders > 0) { throw new Error("Rendered more hooks than during the previous render"); } return { memoizedState: null, queue: null, next: null }; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createHook
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createWorkInProgressHook() { if (workInProgressHook === null) { if (firstWorkInProgressHook === null) { isReRender = false; firstWorkInProgressHook = workInProgressHook = createHook(); } else { isReRender = true...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createWorkInProgressHook
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function prepareToUseHooks(task, componentIdentity) { currentlyRenderingComponent = componentIdentity; currentlyRenderingTask = task; { isInHookUserCodeInDev = false; } localIdCounter = 0; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
prepareToUseHooks
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function finishHooks(Component, props, children, refOrContext) { while (didScheduleRenderPhaseUpdate) { didScheduleRenderPhaseUpdate = false; localIdCounter = 0; numberOfReRenders += 1; workInProgressHook = null; children = Co...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
finishHooks
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function checkDidRenderIdHook() { var didRenderIdHook = localIdCounter !== 0; return didRenderIdHook; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
checkDidRenderIdHook
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function resetHooksState() { { isInHookUserCodeInDev = false; } currentlyRenderingComponent = null; currentlyRenderingTask = null; didScheduleRenderPhaseUpdate = false; firstWorkInProgressHook = null; numbe...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
resetHooksState
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function readContext$1(context) { { if (isInHookUserCodeInDev) { error("Context can only be read while React is rendering. In classes, you can read it in the render method or getDerivedStateFromProps. In function components, you can read it directly in the function body, ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
readContext$1
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useContext(context) { { currentHookNameInDev = "useContext"; } resolveCurrentlyRenderingComponent(); return readContext(context); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useContext
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function basicStateReducer(state, action) { return typeof action === "function" ? action(state) : action; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
basicStateReducer
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useState(initialState) { { currentHookNameInDev = "useState"; } return useReducer( basicStateReducer, // useReducer has a special case to support lazy useState initializers initialState ); ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useState
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useReducer(reducer, initialArg, init) { { if (reducer !== basicStateReducer) { currentHookNameInDev = "useReducer"; } } currentlyRenderingComponent = resolveCurrentlyRenderingComponent(); workInProgressHoo...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useReducer
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useMemo(nextCreate, deps) { currentlyRenderingComponent = resolveCurrentlyRenderingComponent(); workInProgressHook = createWorkInProgressHook(); var nextDeps = deps === void 0 ? null : deps; if (workInProgressHook !== null) { var prevState...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useMemo
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useRef(initialValue) { currentlyRenderingComponent = resolveCurrentlyRenderingComponent(); workInProgressHook = createWorkInProgressHook(); var previousRef = workInProgressHook.memoizedState; if (previousRef === null) { var ref = { ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useRef
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useLayoutEffect(create, inputs) { { currentHookNameInDev = "useLayoutEffect"; error("useLayoutEffect does nothing on the server, because its effect cannot be encoded into the server renderer's output format. This will lead to a mismatch between the initial, non-hyd...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useLayoutEffect
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function dispatchAction(componentIdentity, queue, action) { if (numberOfReRenders >= RE_RENDER_LIMIT) { throw new Error("Too many re-renders. React limits the number of renders to prevent an infinite loop."); } if (componentIdentity === currentlyRenderingCompone...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
dispatchAction
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useCallback(callback, deps) { return useMemo(function() { return callback; }, deps); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useCallback
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useMutableSource(source, getSnapshot, subscribe) { resolveCurrentlyRenderingComponent(); return getSnapshot(source._source); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useMutableSource
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) { if (getServerSnapshot === void 0) { throw new Error("Missing getServerSnapshot, which is required for server-rendered content. Will revert to client rendering."); } return getServerSnapsh...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useSyncExternalStore
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useDeferredValue(value) { resolveCurrentlyRenderingComponent(); return value; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useDeferredValue
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function unsupportedStartTransition() { throw new Error("startTransition cannot be called during server rendering."); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
unsupportedStartTransition
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useTransition() { resolveCurrentlyRenderingComponent(); return [false, unsupportedStartTransition]; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useTransition
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function useId() { var task = currentlyRenderingTask; var treeId = getTreeId(task.treeContext); var responseState = currentResponseState; if (responseState === null) { throw new Error("Invalid hook call. Hooks can only be called inside of the body ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
useId
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function setCurrentResponseState(responseState) { currentResponseState = responseState; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
setCurrentResponseState
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getStackByComponentStackNode(componentStack) { try { var info = ""; var node = componentStack; do { switch (node.tag) { case 0: info += describeBuiltInComponentFrame(node.type, null, null);...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getStackByComponentStackNode
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function defaultErrorHandler(error2) { console["error"](error2); return null; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
defaultErrorHandler
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createRequest(children, responseState, rootFormatContext, progressiveChunkSize, onError, onAllReady, onShellReady, onShellError, onFatalError) { var pingedTasks = []; var abortSet = /* @__PURE__ */ new Set(); var request = { destination: null, ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createRequest
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pingTask(request, task) { var pingedTasks = request.pingedTasks; pingedTasks.push(task); if (pingedTasks.length === 1) { scheduleWork(function() { return performWork(request); }); } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pingTask
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createSuspenseBoundary(request, fallbackAbortableTasks) { return { id: UNINITIALIZED_SUSPENSE_BOUNDARY_ID, rootSegmentID: -1, parentFlushed: false, pendingTasks: 0, forceClientRender: false, completedS...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createSuspenseBoundary
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createTask(request, node, blockedBoundary, blockedSegment, abortSet, legacyContext, context, treeContext) { request.allPendingTasks++; if (blockedBoundary === null) { request.pendingRootTasks++; } else { blockedBoundary.pendingTasks++; ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createTask
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function createPendingSegment(request, index, boundary, formatContext, lastPushedText, textEmbedded) { return { status: PENDING, id: -1, // lazily assigned later index, parentFlushed: false, chunks: [], ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
createPendingSegment
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function getCurrentStackInDEV() { { if (currentTaskInDEV === null || currentTaskInDEV.componentStack === null) { return ""; } return getStackByComponentStackNode(currentTaskInDEV.componentStack); } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
getCurrentStackInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushBuiltInComponentStackInDEV(task, type) { { task.componentStack = { tag: 0, parent: task.componentStack, type }; } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushBuiltInComponentStackInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushFunctionComponentStackInDEV(task, type) { { task.componentStack = { tag: 1, parent: task.componentStack, type }; } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushFunctionComponentStackInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function pushClassComponentStackInDEV(task, type) { { task.componentStack = { tag: 2, parent: task.componentStack, type }; } }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
pushClassComponentStackInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function popComponentStackInDEV(task) { { if (task.componentStack === null) { error("Unexpectedly popped too many stack frames. This is a bug in React."); } else { task.componentStack = task.componentStack.parent; } ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
popComponentStackInDEV
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function captureBoundaryErrorDetailsDev(boundary, error2) { { var errorMessage; if (typeof error2 === "string") { errorMessage = error2; } else if (error2 && typeof error2.message === "string") { errorMessage = error2.mess...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
captureBoundaryErrorDetailsDev
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function logRecoverableError(request, error2) { var errorDigest = request.onError(error2); if (errorDigest != null && typeof errorDigest !== "string") { throw new Error('onError returned something with a type other than "string". onError should return a string and may return ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
logRecoverableError
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function fatalError(request, error2) { var onShellError = request.onShellError; onShellError(error2); var onFatalError = request.onFatalError; onFatalError(error2); if (request.destination !== null) { request.status = CLOSED; ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
fatalError
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function renderSuspenseBoundary(request, task, props) { pushBuiltInComponentStackInDEV(task, "Suspense"); var parentBoundary = task.blockedBoundary; var parentSegment = task.blockedSegment; var fallback = props.fallback; var content = props.children;...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
renderSuspenseBoundary
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function renderHostElement(request, task, type, props) { pushBuiltInComponentStackInDEV(task, type); var segment = task.blockedSegment; var children = pushStartInstance(segment.chunks, type, props, request.responseState, segment.formatContext); segment.lastPushedT...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
renderHostElement
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function shouldConstruct$1(Component) { return Component.prototype && Component.prototype.isReactComponent; }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
shouldConstruct$1
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function renderWithHooks(request, task, Component, props, secondArg) { var componentIdentity = {}; prepareToUseHooks(task, componentIdentity); var result = Component(props, secondArg); return finishHooks(Component, props, result, secondArg); }
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
renderWithHooks
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function finishClassComponent(request, task, instance, Component, props) { var nextChildren = instance.render(); { if (instance.props !== props) { if (!didWarnAboutReassigningProps) { error("It looks like %s is reassigning its own `this.p...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
finishClassComponent
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function renderClassComponent(request, task, Component, props) { pushClassComponentStackInDEV(task, Component); var maskedContext = getMaskedContext(Component, task.legacyContext); var instance = constructClassInstance(Component, props, maskedContext); mountClassI...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
renderClassComponent
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function renderIndeterminateComponent(request, task, Component, props) { var legacyContext; { legacyContext = getMaskedContext(Component, task.legacyContext); } pushFunctionComponentStackInDEV(task, Component); { if (C...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
renderIndeterminateComponent
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT
function validateFunctionComponentInDev(Component) { { if (Component) { if (Component.childContextTypes) { error("%s(...): childContextTypes cannot be defined on a function component.", Component.displayName || Component.name || "Component"); ...
Sets a subset of the state. This only exists because _pendingState is internal. This provides a merging strategy that is not available to deep properties which is confusing. TODO: Expose pendingState or don't use it during the merge. @param {ReactClass} publicInstance The instance that should rerender. @param {object}...
validateFunctionComponentInDev
javascript
wasmerio/winterjs
benchmark/complex.js
https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js
MIT