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 abortTaskSoft(task) {
var request = this;
var boundary = task.blockedBoundary;
var segment = task.blockedSegment;
segment.status = ABORTED;
finishedTask(request, boundary, segment);
} | 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}... | abortTaskSoft | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function abortTask(task, request, reason) {
var boundary = task.blockedBoundary;
var segment = task.blockedSegment;
segment.status = ABORTED;
if (boundary === null) {
request.allPendingTasks--;
if (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}... | abortTask | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function queueCompletedSegment(boundary, segment) {
if (segment.chunks.length === 0 && segment.children.length === 1 && segment.children[0].boundary === null) {
var childSegment = segment.children[0];
childSegment.id = segment.id;
childSegment.parentFlushed ... | 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}... | queueCompletedSegment | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function finishedTask(request, boundary, segment) {
if (boundary === null) {
if (segment.parentFlushed) {
if (request.completedRootSegment !== null) {
throw new Error("There can only be one root segment. This is a bug in React.");
}
... | 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}... | finishedTask | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function retryTask(request, task) {
var segment = task.blockedSegment;
if (segment.status !== PENDING) {
return;
}
switchContext(task.context);
var prevTaskInDEV = null;
{
prevTaskInDEV = currentTaskInDEV... | 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}... | retryTask | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function performWork(request) {
if (request.status === CLOSED) {
return;
}
var prevContext = getActiveContext();
var prevDispatcher = ReactCurrentDispatcher$1.current;
ReactCurrentDispatcher$1.current = Dispatcher;
var 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}... | performWork | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushSubtree(request, destination, segment) {
segment.parentFlushed = true;
switch (segment.status) {
case PENDING: {
var segmentID = segment.id = request.nextSegmentId++;
segment.lastPushedText = false;
segment.t... | 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}... | flushSubtree | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushSegment(request, destination, segment) {
var boundary = segment.boundary;
if (boundary === null) {
return flushSubtree(request, destination, segment);
}
boundary.parentFlushed = true;
if (boundary.forceClientRender) {
... | 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}... | flushSegment | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushClientRenderedBoundary(request, destination, boundary) {
return writeClientRenderBoundaryInstruction(destination, request.responseState, boundary.id, boundary.errorDigest, boundary.errorMessage, boundary.errorComponentStack);
} | 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}... | flushClientRenderedBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushSegmentContainer(request, destination, segment) {
writeStartSegment(destination, request.responseState, segment.formatContext, segment.id);
flushSegment(request, destination, segment);
return writeEndSegment(destination, segment.formatContext);
} | 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}... | flushSegmentContainer | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushCompletedBoundary(request, destination, boundary) {
var completedSegments = boundary.completedSegments;
var i = 0;
for (; i < completedSegments.length; i++) {
var segment = completedSegments[i];
flushPartiallyCompletedSegment(reques... | 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}... | flushCompletedBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushPartialBoundary(request, destination, boundary) {
var completedSegments = boundary.completedSegments;
var i = 0;
for (; i < completedSegments.length; i++) {
var segment = completedSegments[i];
if (!flushPartiallyCompletedSegment(req... | 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}... | flushPartialBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushPartiallyCompletedSegment(request, destination, boundary, segment) {
if (segment.status === FLUSHED) {
return true;
}
var segmentID = segment.id;
if (segmentID === -1) {
var rootSegmentID = segment.id = boundary.rootSe... | 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}... | flushPartiallyCompletedSegment | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flushCompletedQueues(request, destination) {
try {
var completedRootSegment = request.completedRootSegment;
if (completedRootSegment !== null && request.pendingRootTasks === 0) {
flushSegment(request, destination, completedRootSegment);
... | 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}... | flushCompletedQueues | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function startWork(request) {
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}... | startWork | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function startFlowing(request, destination) {
if (request.status === CLOSING) {
request.status = CLOSED;
closeWithError(destination, request.fatalError);
return;
}
if (request.status === CLOSED) {
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}... | startFlowing | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function abort(request, reason) {
try {
var abortableTasks = request.abortableTasks;
abortableTasks.forEach(function(task) {
return abortTask(task, request, reason);
});
abortableTasks.clear();
if (request.de... | 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}... | abort | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function renderToStringImpl(children, options, generateStaticMarkup, abortReason) {
var didFatal = false;
var fatalError2 = null;
var result = "";
var destination = {
push: function(chunk) {
if (chunk !== 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}... | renderToStringImpl | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function onShellReady() {
readyToStream = 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}... | onShellReady | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function renderToString(children, options) {
return renderToStringImpl(children, options, false, 'The server used "renderToString" which does not support Suspense. If you intended for this Suspense boundary to render the fallback content on the server consider throwing an Error somewhere within the Suspen... | 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}... | renderToString | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function renderToStaticMarkup(children, options) {
return renderToStringImpl(children, options, true, 'The server used "renderToStaticMarkup" which does not support Suspense. If you intended to have the server wait for the suspended component please switch to "renderToReadableStream" which supports Suspen... | 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}... | renderToStaticMarkup | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function renderToNodeStream() {
throw new Error("ReactDOMServer.renderToNodeStream(): The streaming API is not available in the browser. Use ReactDOMServer.renderToString() instead.");
} | 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}... | renderToNodeStream | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function renderToStaticNodeStream() {
throw new Error("ReactDOMServer.renderToStaticNodeStream(): The streaming API is not available in the browser. Use ReactDOMServer.renderToStaticMarkup() instead.");
} | 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}... | renderToStaticNodeStream | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function warn(format) {
{
{
for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
args[_key - 1] = arguments[_key];
}
printWarning("warn", format, args);
... | 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}... | warn | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function error(format) {
{
{
for (var _len2 = arguments.length, args = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
args[_key2 - 1] = arguments[_key2];
}
printWarning("error", format, ar... | 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}... | error | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function printWarning(level, format, args) {
{
var ReactDebugCurrentFrame2 = ReactSharedInternals.ReactDebugCurrentFrame;
var stack = ReactDebugCurrentFrame2.getStackAddendum();
if (stack !== "") {
format += "%s";
args = a... | 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}... | printWarning | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function beginWriting(destination) {
currentView = new Uint8Array(VIEW_SIZE);
writtenBytes = 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}... | beginWriting | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeChunk(destination, chunk) {
if (chunk.length === 0) {
return;
}
if (chunk.length > VIEW_SIZE) {
if (writtenBytes > 0) {
destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
cu... | 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}... | writeChunk | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeChunkAndReturn(destination, chunk) {
writeChunk(destination, chunk);
return 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}... | writeChunkAndReturn | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function completeWriting(destination) {
if (currentView && writtenBytes > 0) {
destination.enqueue(new Uint8Array(currentView.buffer, 0, writtenBytes));
currentView = null;
writtenBytes = 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}... | completeWriting | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function stringToChunk(content) {
return textEncoder.encode(content);
} | 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}... | stringToChunk | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function stringToPrecomputedChunk(content) {
return textEncoder.encode(content);
} | 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}... | stringToPrecomputedChunk | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function closeWithError(destination, error2) {
if (typeof destination.error === "function") {
destination.error(error2);
} else {
destination.close();
}
} | 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}... | closeWithError | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function typeName(value) {
{
var hasToStringTag = typeof Symbol === "function" && Symbol.toStringTag;
var type = hasToStringTag && value[Symbol.toStringTag] || value.constructor.name || "Object";
return 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}... | typeName | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function willCoercionThrow(value) {
{
try {
testStringCoercion(value);
return false;
} catch (e) {
return 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}... | willCoercionThrow | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function testStringCoercion(value) {
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}... | testStringCoercion | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function checkAttributeStringCoercion(value, attributeName) {
{
if (willCoercionThrow(value)) {
error("The provided `%s` attribute is an unsupported type %s. This value must be coerced to a string before before using it here.", attributeName, typeName(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}... | checkAttributeStringCoercion | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function checkCSSPropertyStringCoercion(value, propName) {
{
if (willCoercionThrow(value)) {
error("The provided `%s` CSS property is an unsupported type %s. This value must be coerced to a string before before using it here.", propName, typeName(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}... | checkCSSPropertyStringCoercion | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function checkHtmlStringCoercion(value) {
{
if (willCoercionThrow(value)) {
error("The provided HTML markup uses a value of unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
return testStringCoer... | 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}... | checkHtmlStringCoercion | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function isAttributeNameSafe(attributeName) {
if (hasOwnProperty.call(validatedAttributeNameCache, attributeName)) {
return true;
}
if (hasOwnProperty.call(illegalAttributeNameCache, attributeName)) {
return false;
}
i... | 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}... | isAttributeNameSafe | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function shouldRemoveAttributeWithWarning(name, value, propertyInfo, isCustomComponentTag) {
if (propertyInfo !== null && propertyInfo.type === RESERVED) {
return false;
}
switch (typeof value) {
case "function":
case "symbol":
... | 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}... | shouldRemoveAttributeWithWarning | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function getPropertyInfo(name) {
return properties.hasOwnProperty(name) ? properties[name] : 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}... | getPropertyInfo | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function PropertyInfoRecord(name, type, mustUseProperty, attributeName, attributeNamespace, sanitizeURL2, removeEmptyString) {
this.acceptsBooleans = type === BOOLEANISH_STRING || type === BOOLEAN || type === OVERLOADED_BOOLEAN;
this.attributeName = attributeName;
this.attribut... | 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}... | PropertyInfoRecord | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
capitalize = function(token) {
return token[1].toUpperCase();
} | 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}... | capitalize | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function prefixKey(prefix2, key) {
return prefix2 + key.charAt(0).toUpperCase() + key.substring(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}... | prefixKey | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function checkControlledValueProps(tagName, props) {
{
if (!(hasReadOnlyValue[props.type] || props.onChange || props.onInput || props.readOnly || props.disabled || props.value == null)) {
error("You provided a `value` prop to a form field without an `onChange` handler. Th... | 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}... | checkControlledValueProps | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function isCustomComponent(tagName, props) {
if (tagName.indexOf("-") === -1) {
return typeof props.is === "string";
}
switch (tagName) {
case "annotation-xml":
case "color-profile":
case "font-face":
... | 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}... | isCustomComponent | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function validateProperty(tagName, name) {
{
if (hasOwnProperty.call(warnedProperties, name) && warnedProperties[name]) {
return true;
}
if (rARIACamel.test(name)) {
var ariaName = "aria-" + name.slice(4).toLowerCase();
... | 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}... | validateProperty | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function warnInvalidARIAProps(type, props) {
{
var invalidProps = [];
for (var key in props) {
var isValid = validateProperty(type, key);
if (!isValid) {
invalidProps.push(key);
}
}
... | 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}... | warnInvalidARIAProps | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function validateProperties(type, props) {
if (isCustomComponent(type, props)) {
return;
}
warnInvalidARIAProps(type, props);
} | 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}... | validateProperties | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function validateProperties$1(type, props) {
{
if (type !== "input" && type !== "textarea" && type !== "select") {
return;
}
if (props != null && props.value === null && !didWarnValueNull) {
didWarnValueNull = 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}... | validateProperties$1 | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnUnknownProperties = function(type, props, eventRegistry) {
{
var unknownProps = [];
for (var key in props) {
var isValid = validateProperty$1(type, key, props[key], eventRegistry);
if (!isValid) {
unknownProps.push... | 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}... | warnUnknownProperties | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function validateProperties$2(type, props, eventRegistry) {
if (isCustomComponent(type, props)) {
return;
}
warnUnknownProperties(type, props, eventRegistry);
} | 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}... | validateProperties$2 | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
camelize = function(string) {
return string.replace(hyphenPattern, function(_, character) {
return character.toUpperCase();
});
} | 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}... | camelize | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnHyphenatedStyleName = function(name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
error(
"Unsupported style property %s. Did you mean %s?",
... | 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}... | warnHyphenatedStyleName | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnBadVendoredStyleName = function(name) {
if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) {
return;
}
warnedStyleNames[name] = true;
error("Unsupported vendor-prefixed style property %s. Did you mean %s?", name, nam... | 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}... | warnBadVendoredStyleName | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnStyleValueWithSemicolon = function(name, value) {
if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) {
return;
}
warnedStyleValues[value] = true;
error(`Style property values shouldn't contain a semicolon. Try "%... | 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}... | warnStyleValueWithSemicolon | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnStyleValueIsNaN = function(name, value) {
if (warnedForNaNValue) {
return;
}
warnedForNaNValue = true;
error("`NaN` is an invalid value for the `%s` css style property.", name);
} | 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}... | warnStyleValueIsNaN | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
warnStyleValueIsInfinity = function(name, value) {
if (warnedForInfinityValue) {
return;
}
warnedForInfinityValue = true;
error("`Infinity` is an invalid value for the `%s` css style property.", name);
} | 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}... | warnStyleValueIsInfinity | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function escapeHtml(string) {
{
checkHtmlStringCoercion(string);
}
var str = "" + string;
var match = matchHtmlRegExp.exec(str);
if (!match) {
return str;
}
var escape;
var htm... | 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}... | escapeHtml | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function escapeTextForBrowser(text) {
if (typeof text === "boolean" || typeof text === "number") {
return "" + text;
}
return escapeHtml(text);
} | 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}... | escapeTextForBrowser | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function hyphenateStyleName(name) {
return name.replace(uppercasePattern, "-$1").toLowerCase().replace(msPattern$1, "-ms-");
} | 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}... | hyphenateStyleName | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function sanitizeURL(url) {
{
if (!didWarn && isJavaScriptProtocol.test(url)) {
didWarn = true;
error("A future version of React will block javascript: URLs as a security precaution. Use event handlers instead if you can. If you need to generate unsafe H... | 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}... | sanitizeURL | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function isArray(a) {
return isArrayImpl(a);
} | 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}... | isArray | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function escapeBootstrapScriptContent(scriptText) {
{
checkHtmlStringCoercion(scriptText);
}
return ("" + scriptText).replace(scriptRegex, scriptReplacer);
} | 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}... | escapeBootstrapScriptContent | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
scriptReplacer = function(match, prefix2, s, suffix) {
return "" + prefix2 + (s === "s" ? "\\u0073" : "\\u0053") + suffix;
} | 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}... | scriptReplacer | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function createResponseState(identifierPrefix, nonce, bootstrapScriptContent, bootstrapScripts, bootstrapModules) {
var idPrefix = identifierPrefix === void 0 ? "" : identifierPrefix;
var inlineScriptWithNonce = nonce === void 0 ? startInlineScript : stringToPrecomputedChunk('<script nonce="... | 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}... | createResponseState | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function createFormatContext(insertionMode, selectedValue) {
return {
insertionMode,
selectedValue
};
} | 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}... | createFormatContext | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function createRootFormatContext(namespaceURI) {
var insertionMode = namespaceURI === "http://www.w3.org/2000/svg" ? SVG_MODE : namespaceURI === "http://www.w3.org/1998/Math/MathML" ? MATHML_MODE : ROOT_HTML_MODE;
return createFormatContext(insertionMode, 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}... | createRootFormatContext | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function getChildFormatContext(parentContext, type, props) {
switch (type) {
case "select":
return createFormatContext(HTML_MODE, props.value != null ? props.value : props.defaultValue);
case "svg":
return createFormatContext(SVG_MODE, nu... | 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}... | getChildFormatContext | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function assignSuspenseBoundaryID(responseState) {
var generatedID = responseState.nextSuspenseID++;
return stringToPrecomputedChunk(responseState.boundaryPrefix + generatedID.toString(16));
} | 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}... | assignSuspenseBoundaryID | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function makeId(responseState, treeId, localId) {
var idPrefix = responseState.idPrefix;
var id = ":" + idPrefix + "R" + treeId;
if (localId > 0) {
id += "H" + localId.toString(32);
}
return id + ":";
} | 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}... | makeId | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function encodeHTMLTextNode(text) {
return escapeTextForBrowser(text);
} | 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}... | encodeHTMLTextNode | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushTextInstance(target, text, responseState, textEmbedded) {
if (text === "") {
return textEmbedded;
}
if (textEmbedded) {
target.push(textSeparator);
}
target.push(stringToChunk(encodeHTMLTextNode(text)));
... | 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}... | pushTextInstance | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushSegmentFinale(target, responseState, lastPushedText, textEmbedded) {
if (lastPushedText && textEmbedded) {
target.push(textSeparator);
}
} | 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}... | pushSegmentFinale | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function processStyleName(styleName) {
var chunk = styleNameCache.get(styleName);
if (chunk !== void 0) {
return chunk;
}
var result = stringToPrecomputedChunk(escapeTextForBrowser(hyphenateStyleName(styleName)));
styleNameCache.set(s... | 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}... | processStyleName | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStyle(target, responseState, style) {
if (typeof style !== "object") {
throw new Error("The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + 'em'}} when using JSX.");
}
var isF... | 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}... | pushStyle | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushAttribute(target, responseState, name, value) {
switch (name) {
case "style": {
pushStyle(target, responseState, value);
return;
}
case "defaultValue":
case "defaultChecked":
ca... | 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}... | pushAttribute | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushInnerHTML(target, innerHTML, children) {
if (innerHTML != null) {
if (children != null) {
throw new Error("Can only set one of `children` or `props.dangerouslySetInnerHTML`.");
}
if (typeof innerHTML !== "object" || !("__html" ... | 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}... | pushInnerHTML | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function checkSelectProp(props, propName) {
{
var value = props[propName];
if (value != null) {
var array = isArray(value);
if (props.multiple && !array) {
error("The `%s` prop supplied to <select> must be an array 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}... | checkSelectProp | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartSelect(target, props, responseState) {
{
checkControlledValueProps("select", props);
checkSelectProp(props, "value");
checkSelectProp(props, "defaultValue");
if (props.value !== void 0 && props.defaultValue !== void 0 && !di... | 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}... | pushStartSelect | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function flattenOptionChildren(children) {
var content = "";
React3.Children.forEach(children, function(child) {
if (child == null) {
return;
}
content += child;
{
if (!didWarnInvalidOptionChi... | 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}... | flattenOptionChildren | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartOption(target, props, responseState, formatContext) {
var selectedValue = formatContext.selectedValue;
target.push(startChunkForTag("option"));
var children = null;
var value = null;
var selected = null;
var innerHTML ... | 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}... | pushStartOption | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushInput(target, props, responseState) {
{
checkControlledValueProps("input", props);
if (props.checked !== void 0 && props.defaultChecked !== void 0 && !didWarnDefaultChecked) {
error("%s contains an input of type %s with both checked and defaul... | 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}... | pushInput | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartTextArea(target, props, responseState) {
{
checkControlledValueProps("textarea", props);
if (props.value !== void 0 && props.defaultValue !== void 0 && !didWarnDefaultTextareaValue) {
error("Textarea elements must be either controlled or ... | 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}... | pushStartTextArea | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushSelfClosing(target, props, tag, responseState) {
target.push(startChunkForTag(tag));
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var propValue = props[propKey];
if (propValue == 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}... | pushSelfClosing | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartMenuItem(target, props, responseState) {
target.push(startChunkForTag("menuitem"));
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var propValue = props[propKey];
if (propValue == 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}... | pushStartMenuItem | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartTitle(target, props, responseState) {
target.push(startChunkForTag("title"));
var children = null;
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var propValue = props[propKey];
if (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}... | pushStartTitle | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartGenericElement(target, props, tag, responseState) {
target.push(startChunkForTag(tag));
var children = null;
var innerHTML = null;
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var propV... | 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}... | pushStartGenericElement | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartCustomElement(target, props, tag, responseState) {
target.push(startChunkForTag(tag));
var children = null;
var innerHTML = null;
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var propVa... | 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}... | pushStartCustomElement | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartPreformattedElement(target, props, tag, responseState) {
target.push(startChunkForTag(tag));
var children = null;
var innerHTML = null;
for (var propKey in props) {
if (hasOwnProperty.call(props, propKey)) {
var ... | 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}... | pushStartPreformattedElement | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function startChunkForTag(tag) {
var tagStartChunk = validatedTagCache.get(tag);
if (tagStartChunk === void 0) {
if (!VALID_TAG_REGEX.test(tag)) {
throw new Error("Invalid tag: " + tag);
}
tagStartChunk = stringToPrecomputedCh... | 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}... | startChunkForTag | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushStartInstance(target, type, props, responseState, formatContext) {
{
validateProperties(type, props);
validateProperties$1(type, props);
validateProperties$2(type, props, null);
if (!props.suppressContentEditableWarning && props.... | 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}... | pushStartInstance | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function pushEndInstance(target, type, props) {
switch (type) {
case "area":
case "base":
case "br":
case "col":
case "embed":
case "hr":
case "img":
case "input":
... | 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}... | pushEndInstance | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeCompletedRoot(destination, responseState) {
var bootstrapChunks = responseState.bootstrapChunks;
var i = 0;
for (; i < bootstrapChunks.length - 1; i++) {
writeChunk(destination, bootstrapChunks[i]);
}
if (i < bootstrapCh... | 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}... | writeCompletedRoot | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writePlaceholder(destination, responseState, id) {
writeChunk(destination, placeholder1);
writeChunk(destination, responseState.placeholderPrefix);
var formattedID = stringToChunk(id.toString(16));
writeChunk(destination, formattedID);
retur... | 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}... | writePlaceholder | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeStartCompletedSuspenseBoundary(destination, responseState) {
return writeChunkAndReturn(destination, startCompletedSuspenseBoundary);
} | 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}... | writeStartCompletedSuspenseBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeStartPendingSuspenseBoundary(destination, responseState, id) {
writeChunk(destination, startPendingSuspenseBoundary1);
if (id === null) {
throw new Error("An ID must have been assigned before we can complete the boundary.");
}
writeCh... | 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}... | writeStartPendingSuspenseBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeStartClientRenderedSuspenseBoundary(destination, responseState, errorDigest, errorMesssage, errorComponentStack) {
var result;
result = writeChunkAndReturn(destination, startClientRenderedSuspenseBoundary);
writeChunk(destination, clientRenderedSuspenseBoundaryErr... | 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}... | writeStartClientRenderedSuspenseBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
function writeEndCompletedSuspenseBoundary(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}... | writeEndCompletedSuspenseBoundary | javascript | wasmerio/winterjs | benchmark/complex.js | https://github.com/wasmerio/winterjs/blob/master/benchmark/complex.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.