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 |
|---|---|---|---|---|---|---|---|
get initialized() {
return this.initializedFlag;
} | The preventDefault() method steps are to set the canceled flag with this. | initialized | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
set initialized(value) {
this.initializedFlag = value;
} | The preventDefault() method steps are to set the canceled flag with this. | initialized | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
constructor() {
// The new EventTarget() constructor steps are to do nothing.
} | @see: https://dom.spec.whatwg.org/#eventtarget | constructor | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
removeEventListener(type, callback, options) {
const self = this;
const { listeners } = self.eventTargetData;
const notExistListeners = !listeners[type] || listeners[type].length === 0;
if (notExistListeners)
return;
// flatten options
... | @see: https://dom.spec.whatwg.org/#eventtarget | removeEventListener | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
flattenOptions(options) {
if (typeof options === "boolean") {
return { capture: options, once: false, passive: false };
}
return options;
} | @see: https://dom.spec.whatwg.org/#eventtarget | flattenOptions | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
function dispatch(eventTarget, event) {
// Tentative implementation that just calls the callback
eventTarget.eventTargetData.listeners[event.type].forEach((listener) => {
listener.callback(event);
});
return true;
} | @see: https://dom.spec.whatwg.org/#eventtarget | dispatch | javascript | wasmerio/winterjs | src/builtins/js_globals/event.js | https://github.com/wasmerio/winterjs/blob/master/src/builtins/js_globals/event.js | MIT |
function Component(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
} | 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}... | Component | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
defineDeprecationWarning = function(methodName, info) {
Object.defineProperty(Component.prototype, methodName, {
get: function() {
warn("%s(...) is deprecated in plain JavaScript React classes. %s", info[0], info[1]);
return 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}... | defineDeprecationWarning | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function PureComponent(props, context, updater) {
this.props = props;
this.context = context;
this.refs = emptyObject;
this.updater = updater || ReactNoopUpdateQueue;
} | 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}... | PureComponent | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function createRef() {
var refObject = {
current: null
};
{
Object.seal(refObject);
}
return refObject;
} | 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}... | createRef | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function checkKeyStringCoercion(value) {
{
if (willCoercionThrow(value)) {
error("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", typeName(value));
return testStringCoercion(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}... | checkKeyStringCoercion | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function hasValidRef(config) {
{
if (hasOwnProperty.call(config, "ref")) {
var getter = Object.getOwnPropertyDescriptor(config, "ref").get;
if (getter && getter.isReactWarning) {
return 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}... | hasValidRef | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function hasValidKey(config) {
{
if (hasOwnProperty.call(config, "key")) {
var getter = Object.getOwnPropertyDescriptor(config, "key").get;
if (getter && getter.isReactWarning) {
return 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}... | hasValidKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function defineKeyPropWarningGetter(props, displayName) {
var warnAboutAccessingKey = function() {
{
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
error("%s: `key` is not a prop. Trying to access it will resu... | 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}... | defineKeyPropWarningGetter | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
warnAboutAccessingKey = function() {
{
if (!specialPropKeyWarningShown) {
specialPropKeyWarningShown = true;
error("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value withi... | 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}... | warnAboutAccessingKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function defineRefPropWarningGetter(props, displayName) {
var warnAboutAccessingRef = function() {
{
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
error("%s: `ref` is not a prop. Trying to access it will resu... | 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}... | defineRefPropWarningGetter | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
warnAboutAccessingRef = function() {
{
if (!specialPropRefWarningShown) {
specialPropRefWarningShown = true;
error("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value withi... | 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}... | warnAboutAccessingRef | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function warnIfStringRefCannotBeAutoConverted(config) {
{
if (typeof config.ref === "string" && ReactCurrentOwner.current && config.__self && ReactCurrentOwner.current.stateNode !== config.__self) {
var componentName = getComponentNameFromType(ReactCurrentOwner.current.ty... | 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}... | warnIfStringRefCannotBeAutoConverted | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
ReactElement = function(type, key, ref, self, source, owner, props) {
var element = {
// This tag allows us to uniquely identify this as a React Element
$$typeof: REACT_ELEMENT_TYPE,
// Built-in properties that belong on the element
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}... | ReactElement | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function createElement(type, config, children) {
var propName;
var props = {};
var key = null;
var ref = null;
var self = null;
var source = null;
if (config != null) {
if (hasValidRef(config)) {
... | 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}... | createElement | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function cloneAndReplaceKey(oldElement, newKey) {
var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props);
return newElement;
} | 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}... | cloneAndReplaceKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function cloneElement(element, config, children) {
if (element === null || element === void 0) {
throw new Error("React.cloneElement(...): The argument must be a React element, but you passed " + element + ".");
}
var propName;
var props = assign({... | 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}... | cloneElement | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function isValidElement(object) {
return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_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}... | isValidElement | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function escape(key) {
var escapeRegex = /[=:]/g;
var escaperLookup = {
"=": "=0",
":": "=2"
};
var escapedString = key.replace(escapeRegex, function(match) {
return escaperLookup[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}... | escape | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function escapeUserProvidedKey(text) {
return text.replace(userProvidedKeyEscapeRegex, "$&/");
} | 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}... | escapeUserProvidedKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function getElementKey(element, index) {
if (typeof element === "object" && element !== null && element.key != null) {
{
checkKeyStringCoercion(element.key);
}
return escape("" + element.key);
}
return index.toSt... | 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}... | getElementKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function mapIntoArray(children, array, escapedPrefix, nameSoFar, callback) {
var type = typeof children;
if (type === "undefined" || type === "boolean") {
children = null;
}
var invokeCallback = false;
if (children === 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}... | mapIntoArray | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function mapChildren(children, func, context) {
if (children == null) {
return children;
}
var result = [];
var count = 0;
mapIntoArray(children, result, "", "", function(child) {
return func.call(context, child, count... | 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}... | mapChildren | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function countChildren(children) {
var n = 0;
mapChildren(children, function() {
n++;
});
return n;
} | 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}... | countChildren | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function forEachChildren(children, forEachFunc, forEachContext) {
mapChildren(children, function() {
forEachFunc.apply(this, arguments);
}, forEachContext);
} | 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}... | forEachChildren | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function toArray(children) {
return mapChildren(children, function(child) {
return child;
}) || [];
} | 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}... | toArray | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function onlyChild(children) {
if (!isValidElement(children)) {
throw new Error("React.Children.only expected to receive a single React element child.");
}
return 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}... | onlyChild | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function createContext(defaultValue) {
var context = {
$$typeof: REACT_CONTEXT_TYPE,
// As a workaround to support multiple concurrent renderers, we categorize
// some renderers as primary and others as secondary. We only expect
// there to b... | 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}... | createContext | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function lazyInitializer(payload) {
if (payload._status === Uninitialized) {
var ctor = payload._result;
var thenable = ctor();
thenable.then(function(moduleObject2) {
if (payload._status === Pending || payload._status === Uninitialized) {
... | 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}... | lazyInitializer | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function lazy(ctor) {
var payload = {
// We use these fields to store the result.
_status: Uninitialized,
_result: ctor
};
var lazyType = {
$$typeof: REACT_LAZY_TYPE,
_payload: payload,
... | 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}... | lazy | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function forwardRef(render) {
{
if (render != null && render.$$typeof === REACT_MEMO_TYPE) {
error("forwardRef requires a render function but received a `memo` component. Instead of forwardRef(memo(...)), use memo(forwardRef(...)).");
} else if (typeof ren... | 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}... | forwardRef | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function isValidElementType(type) {
if (typeof type === "string" || typeof type === "function") {
return true;
}
if (type === REACT_FRAGMENT_TYPE || type === REACT_PROFILER_TYPE || enableDebugTracing || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_... | 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}... | isValidElementType | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function memo(type, compare) {
{
if (!isValidElementType(type)) {
error("memo: The first argument must be a component. Instead received: %s", type === null ? "null" : typeof type);
}
}
var elementType = {
$$typeo... | 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}... | memo | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function resolveDispatcher() {
var dispatcher = ReactCurrentDispatcher.current;
{
if (dispatcher === null) {
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... | 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}... | resolveDispatcher | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useContext(Context) {
var dispatcher = resolveDispatcher();
{
if (Context._context !== void 0) {
var realContext = Context._context;
if (realContext.Consumer === Context) {
error("Calling useContext(Context.Cons... | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useState(initialState) {
var dispatcher = resolveDispatcher();
return dispatcher.useState(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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useReducer(reducer, initialArg, init) {
var dispatcher = resolveDispatcher();
return dispatcher.useReducer(reducer, initialArg, init);
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useRef(initialValue) {
var dispatcher = resolveDispatcher();
return dispatcher.useRef(initialValue);
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useEffect(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useEffect(create, 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}... | useEffect | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useInsertionEffect(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useInsertionEffect(create, 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}... | useInsertionEffect | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useLayoutEffect(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useLayoutEffect(create, 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}... | useLayoutEffect | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useCallback(callback, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useCallback(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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useMemo(create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useMemo(create, 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}... | useMemo | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useImperativeHandle(ref, create, deps) {
var dispatcher = resolveDispatcher();
return dispatcher.useImperativeHandle(ref, create, 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}... | useImperativeHandle | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useDebugValue(value, formatterFn) {
{
var dispatcher = resolveDispatcher();
return dispatcher.useDebugValue(value, formatterFn);
}
} | 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}... | useDebugValue | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useTransition() {
var dispatcher = resolveDispatcher();
return dispatcher.useTransition();
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useDeferredValue(value) {
var dispatcher = resolveDispatcher();
return dispatcher.useDeferredValue(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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useId() {
var dispatcher = resolveDispatcher();
return dispatcher.useId();
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
var dispatcher = resolveDispatcher();
return dispatcher.useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function shouldConstruct(Component2) {
var prototype = Component2.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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function setCurrentlyValidatingElement(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
ReactDebugCurrentFrame$1.setExtra... | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function setCurrentlyValidatingElement$1(element) {
{
if (element) {
var owner = element._owner;
var stack = describeUnknownElementTypeFrameInDEV(element.type, element._source, owner ? owner.type : null);
setExtraStackFrame(stack);
... | 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$1 | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function getDeclarationErrorAddendum() {
if (ReactCurrentOwner.current) {
var name = getComponentNameFromType(ReactCurrentOwner.current.type);
if (name) {
return "\n\nCheck the render method of `" + 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}... | getDeclarationErrorAddendum | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function getSourceInfoErrorAddendum(source) {
if (source !== void 0) {
var fileName = source.fileName.replace(/^.*[\\\/]/, "");
var lineNumber = source.lineNumber;
return "\n\nCheck your code at " + fileName + ":" + lineNumber + ".";
}
... | 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}... | getSourceInfoErrorAddendum | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function getSourceInfoErrorAddendumForProps(elementProps) {
if (elementProps !== null && elementProps !== void 0) {
return getSourceInfoErrorAddendum(elementProps.__source);
}
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}... | getSourceInfoErrorAddendumForProps | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function getCurrentComponentErrorInfo(parentType) {
var info = getDeclarationErrorAddendum();
if (!info) {
var parentName = typeof parentType === "string" ? parentType : parentType.displayName || parentType.name;
if (parentName) {
info = "\n\... | 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}... | getCurrentComponentErrorInfo | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function validateExplicitKey(element, parentType) {
if (!element._store || element._store.validated || element.key != null) {
return;
}
element._store.validated = true;
var currentComponentErrorInfo = getCurrentComponentErrorInfo(parentType);
... | 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}... | validateExplicitKey | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function validateChildKeys(node, parentType) {
if (typeof node !== "object") {
return;
}
if (isArray(node)) {
for (var i = 0; i < node.length; i++) {
var child = node[i];
if (isValidElement(child)) {
... | 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}... | validateChildKeys | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function validatePropTypes(element) {
{
var type = element.type;
if (type === null || type === void 0 || typeof type === "string") {
return;
}
var propTypes;
if (typeof type === "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}... | validatePropTypes | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function validateFragmentProps(fragment) {
{
var keys = Object.keys(fragment.props);
for (var i = 0; i < keys.length; i++) {
var key = keys[i];
if (key !== "children" && key !== "key") {
setCurrentlyValidatingElement$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}... | validateFragmentProps | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function createElementWithValidation(type, props, children) {
var validType = isValidElementType(type);
if (!validType) {
var info = "";
if (type === void 0 || typeof type === "object" && type !== null && Object.keys(type).length === 0) {
inf... | 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}... | createElementWithValidation | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function createFactoryWithValidation(type) {
var validatedFactory = createElementWithValidation.bind(null, type);
validatedFactory.type = type;
{
if (!didWarnAboutDeprecatedCreateFactory) {
didWarnAboutDeprecatedCreateFactory = 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}... | createFactoryWithValidation | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function cloneElementWithValidation(element, props, children) {
var newElement = cloneElement.apply(this, arguments);
for (var i = 2; i < arguments.length; i++) {
validateChildKeys(arguments[i], newElement.type);
}
validatePropTypes(newElement);
... | 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}... | cloneElementWithValidation | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function startTransition(scope, options) {
var prevTransition = ReactCurrentBatchConfig.transition;
ReactCurrentBatchConfig.transition = {};
var currentTransition = ReactCurrentBatchConfig.transition;
{
ReactCurrentBatchConfig.transition._updatedFi... | 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}... | startTransition | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function enqueueTask(task) {
if (enqueueTaskImpl === null) {
try {
var requireString = ("require" + Math.random()).slice(0, 7);
var nodeRequire = module && module[requireString];
enqueueTaskImpl = nodeRequire.call(module, "timers").setI... | 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}... | enqueueTask | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function act(callback) {
{
var prevActScopeDepth = actScopeDepth;
actScopeDepth++;
if (ReactCurrentActQueue.current === null) {
ReactCurrentActQueue.current = [];
}
var prevIsBatchingLegacy = ReactCurrentActQ... | 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}... | act | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function popActScope(prevActScopeDepth) {
{
if (prevActScopeDepth !== actScopeDepth - 1) {
error("You seem to have overlapping act() calls, this is not supported. Be sure to await previous act() calls before making a new one. ");
}
actScope... | 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}... | popActScope | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function recursivelyFlushAsyncActWork(returnValue, resolve, reject) {
{
var queue = ReactCurrentActQueue.current;
if (queue !== null) {
try {
flushActQueue(queue);
enqueueTask(function() {
if (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}... | recursivelyFlushAsyncActWork | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function flushActQueue(queue) {
{
if (!isFlushing) {
isFlushing = true;
var i = 0;
try {
for (; i < queue.length; i++) {
var callback = queue[i];
do {
... | 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}... | flushActQueue | javascript | wasmerio/winterjs | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function writeChunk(destination, chunk) {
writeChunkAndReturn(destination, chunk);
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function writeChunkAndReturn(destination, chunk) {
return destination.push(chunk);
} | 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function stringToChunk(content) {
return 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
function stringToPrecomputedChunk(content) {
return 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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/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 | tests/complex.js | https://github.com/wasmerio/winterjs/blob/master/tests/complex.js | MIT |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.