code
stringlengths 28
313k
| docstring
stringlengths 25
85.3k
| func_name
stringlengths 1
74
| language
stringclasses 1
value | repo
stringlengths 5
60
| path
stringlengths 4
172
| url
stringlengths 44
218
| license
stringclasses 7
values |
|---|---|---|---|---|---|---|---|
function getFallbackBeforeInputChars(topLevelType, nativeEvent) {
// If we are currently composing (IME) and using a fallback to do so,
// try to extract the composed characters from the fallback object.
// If composition event is available, we extract a string only at
// compositionevent, otherwise extract it at fallback events.
if (currentComposition) {
if (topLevelType === 'topCompositionEnd' || !canUseCompositionEvent && isFallbackCompositionEnd(topLevelType, nativeEvent)) {
var chars = currentComposition.getData();
FallbackCompositionState.release(currentComposition);
currentComposition = null;
return chars;
}
return null;
}
switch (topLevelType) {
case 'topPaste':
// If a paste event occurs after a keypress, throw out the input
// chars. Paste events should not lead to BeforeInput events.
return null;
case 'topKeyPress':
/**
* As of v27, Firefox may fire keypress events even when no character
* will be inserted. A few possibilities:
*
* - `which` is `0`. Arrow keys, Esc key, etc.
*
* - `which` is the pressed key code, but no char is available.
* Ex: 'AltGr + d` in Polish. There is no modified character for
* this key combination and no character is inserted into the
* document, but FF fires the keypress for char code `100` anyway.
* No `input` event will occur.
*
* - `which` is the pressed key code, but a command combination is
* being used. Ex: `Cmd+C`. No character is inserted, and no
* `input` event will occur.
*/
if (nativeEvent.which && !isKeypressCommand(nativeEvent)) {
return String.fromCharCode(nativeEvent.which);
}
return null;
case 'topCompositionEnd':
return useFallbackCompositionData ? null : nativeEvent.data;
default:
return null;
}
}
|
For browsers that do not provide the `textInput` event, extract the
appropriate string to use for SyntheticInputEvent.
@param {string} topLevelType Record from `EventConstants`.
@param {object} nativeEvent Native browser event.
@return {?string} The fallback string for this `beforeInput` event.
|
getFallbackBeforeInputChars
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function extractBeforeInputEvent(topLevelType, targetInst, nativeEvent, nativeEventTarget) {
var chars;
if (canUseTextInputEvent) {
chars = getNativeBeforeInputChars(topLevelType, nativeEvent);
} else {
chars = getFallbackBeforeInputChars(topLevelType, nativeEvent);
}
// If no characters are being inserted, no BeforeInput event should
// be fired.
if (!chars) {
return null;
}
var event = SyntheticInputEvent.getPooled(eventTypes.beforeInput, targetInst, nativeEvent, nativeEventTarget);
event.data = chars;
EventPropagators.accumulateTwoPhaseDispatches(event);
return event;
}
|
Extract a SyntheticInputEvent for `beforeInput`, based on either native
`textInput` or fallback behavior.
@return {?object} A SyntheticInputEvent.
|
extractBeforeInputEvent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function listenerAtPhase(inst, event, propagationPhase) {
var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase];
return getListener(inst, registrationName);
}
|
Some event types have a notion of different registration names for different
"phases" of propagation. This finds listeners by a given phase.
|
listenerAtPhase
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateDirectionalDispatches(inst, phase, event) {
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(inst, 'Dispatching inst must not be null') : void 0;
}
var listener = listenerAtPhase(inst, event, phase);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
|
Tags a `SyntheticEvent` with dispatched listeners. Creating this function
here, allows us to not have to bind or create functions for each event.
Mutating the event's members allows us to not have to create a wrapping
"dispatch" object that pairs the event with the listener.
|
accumulateDirectionalDispatches
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateTwoPhaseDispatchesSingle(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
EventPluginUtils.traverseTwoPhase(event._targetInst, accumulateDirectionalDispatches, event);
}
}
|
Collect dispatches (must be entirely collected before dispatching - see unit
tests). Lazily allocate the array to conserve memory. We must loop through
each event and perform the traversal for each one. We cannot perform a
single traversal for the entire collection of events because each event may
have a different target.
|
accumulateTwoPhaseDispatchesSingle
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateTwoPhaseDispatchesSingleSkipTarget(event) {
if (event && event.dispatchConfig.phasedRegistrationNames) {
var targetInst = event._targetInst;
var parentInst = targetInst ? EventPluginUtils.getParentInstance(targetInst) : null;
EventPluginUtils.traverseTwoPhase(parentInst, accumulateDirectionalDispatches, event);
}
}
|
Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID.
|
accumulateTwoPhaseDispatchesSingleSkipTarget
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateDispatches(inst, ignoredDirection, event) {
if (event && event.dispatchConfig.registrationName) {
var registrationName = event.dispatchConfig.registrationName;
var listener = getListener(inst, registrationName);
if (listener) {
event._dispatchListeners = accumulateInto(event._dispatchListeners, listener);
event._dispatchInstances = accumulateInto(event._dispatchInstances, inst);
}
}
}
|
Accumulates without regard to direction, does not look for phased
registration names. Same as `accumulateDirectDispatchesSingle` but without
requiring that the `dispatchMarker` be the same as the dispatched ID.
|
accumulateDispatches
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateDirectDispatchesSingle(event) {
if (event && event.dispatchConfig.registrationName) {
accumulateDispatches(event._targetInst, null, event);
}
}
|
Accumulates dispatches on an `SyntheticEvent`, but only for the
`dispatchMarker`.
@param {SyntheticEvent} event
|
accumulateDirectDispatchesSingle
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
executeDispatchesAndRelease = function (event, simulated) {
if (event) {
EventPluginUtils.executeDispatchesInOrder(event, simulated);
if (!event.isPersistent()) {
event.constructor.release(event);
}
}
}
|
Dispatches an event and releases it back into the pool, unless persistent.
@param {?object} event Synthetic event to be dispatched.
@param {boolean} simulated If the event is simulated (changes exn behavior)
@private
|
executeDispatchesAndRelease
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function recomputePluginOrdering() {
if (!eventPluginOrder) {
// Wait until an `eventPluginOrder` is injected.
return;
}
for (var pluginName in namesToPlugins) {
var pluginModule = namesToPlugins[pluginName];
var pluginIndex = eventPluginOrder.indexOf(pluginName);
!(pluginIndex > -1) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in the plugin ordering, `%s`.', pluginName) : _prodInvariant('96', pluginName) : void 0;
if (EventPluginRegistry.plugins[pluginIndex]) {
continue;
}
!pluginModule.extractEvents ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` method, but `%s` does not.', pluginName) : _prodInvariant('97', pluginName) : void 0;
EventPluginRegistry.plugins[pluginIndex] = pluginModule;
var publishedEvents = pluginModule.eventTypes;
for (var eventName in publishedEvents) {
!publishEventForPlugin(publishedEvents[eventName], pluginModule, eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : _prodInvariant('98', eventName, pluginName) : void 0;
}
}
}
|
Recomputes the plugin list using the injected plugins and plugin ordering.
@private
|
recomputePluginOrdering
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function publishEventForPlugin(dispatchConfig, pluginModule, eventName) {
!!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same event name, `%s`.', eventName) : _prodInvariant('99', eventName) : void 0;
EventPluginRegistry.eventNameDispatchConfigs[eventName] = dispatchConfig;
var phasedRegistrationNames = dispatchConfig.phasedRegistrationNames;
if (phasedRegistrationNames) {
for (var phaseName in phasedRegistrationNames) {
if (phasedRegistrationNames.hasOwnProperty(phaseName)) {
var phasedRegistrationName = phasedRegistrationNames[phaseName];
publishRegistrationName(phasedRegistrationName, pluginModule, eventName);
}
}
return true;
} else if (dispatchConfig.registrationName) {
publishRegistrationName(dispatchConfig.registrationName, pluginModule, eventName);
return true;
}
return false;
}
|
Publishes an event so that it can be dispatched by the supplied plugin.
@param {object} dispatchConfig Dispatch configuration for the event.
@param {object} PluginModule Plugin publishing the event.
@return {boolean} True if the event was successfully published.
@private
|
publishEventForPlugin
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function publishRegistrationName(registrationName, pluginModule, eventName) {
!!EventPluginRegistry.registrationNameModules[registrationName] ? process.env.NODE_ENV !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same registration name, `%s`.', registrationName) : _prodInvariant('100', registrationName) : void 0;
EventPluginRegistry.registrationNameModules[registrationName] = pluginModule;
EventPluginRegistry.registrationNameDependencies[registrationName] = pluginModule.eventTypes[eventName].dependencies;
if (process.env.NODE_ENV !== 'production') {
var lowerCasedName = registrationName.toLowerCase();
EventPluginRegistry.possibleRegistrationNames[lowerCasedName] = registrationName;
if (registrationName === 'onDoubleClick') {
EventPluginRegistry.possibleRegistrationNames.ondblclick = registrationName;
}
}
}
|
Publishes a registration name that is used to identify dispatched events and
can be used with `EventPluginHub.putListener` to register listeners.
@param {string} registrationName Registration name to add.
@param {object} PluginModule Plugin publishing the event.
@private
|
publishRegistrationName
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isEndish(topLevelType) {
return topLevelType === 'topMouseUp' || topLevelType === 'topTouchEnd' || topLevelType === 'topTouchCancel';
}
|
- `ComponentTree`: [required] Module that can convert between React instances
and actual node references.
|
isEndish
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function executeDispatch(event, simulated, listener, inst) {
var type = event.type || 'unknown-event';
event.currentTarget = EventPluginUtils.getNodeFromInstance(inst);
if (simulated) {
ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event);
} else {
ReactErrorUtils.invokeGuardedCallback(type, listener, event);
}
event.currentTarget = null;
}
|
Dispatch the event to the listener.
@param {SyntheticEvent} event SyntheticEvent to handle
@param {boolean} simulated If the event is simulated (changes exn behavior)
@param {function} listener Application-level callback
@param {*} inst Internal component instance
|
executeDispatch
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function executeDispatchesInOrder(event, simulated) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and Instances are two parallel arrays that are always in sync.
executeDispatch(event, simulated, dispatchListeners[i], dispatchInstances[i]);
}
} else if (dispatchListeners) {
executeDispatch(event, simulated, dispatchListeners, dispatchInstances);
}
event._dispatchListeners = null;
event._dispatchInstances = null;
}
|
Standard/simple iteration through an event's collected dispatches.
|
executeDispatchesInOrder
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function executeDispatchesInOrderStopAtTrueImpl(event) {
var dispatchListeners = event._dispatchListeners;
var dispatchInstances = event._dispatchInstances;
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
if (Array.isArray(dispatchListeners)) {
for (var i = 0; i < dispatchListeners.length; i++) {
if (event.isPropagationStopped()) {
break;
}
// Listeners and Instances are two parallel arrays that are always in sync.
if (dispatchListeners[i](event, dispatchInstances[i])) {
return dispatchInstances[i];
}
}
} else if (dispatchListeners) {
if (dispatchListeners(event, dispatchInstances)) {
return dispatchInstances;
}
}
return null;
}
|
Standard/simple iteration through an event's collected dispatches, but stops
at the first dispatch execution returning true, and returns that id.
@return {?string} id of the first dispatch execution who's listener returns
true, or null if no listener returned true.
|
executeDispatchesInOrderStopAtTrueImpl
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function executeDirectDispatch(event) {
if (process.env.NODE_ENV !== 'production') {
validateEventDispatches(event);
}
var dispatchListener = event._dispatchListeners;
var dispatchInstance = event._dispatchInstances;
!!Array.isArray(dispatchListener) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : _prodInvariant('103') : void 0;
event.currentTarget = dispatchListener ? EventPluginUtils.getNodeFromInstance(dispatchInstance) : null;
var res = dispatchListener ? dispatchListener(event) : null;
event.currentTarget = null;
event._dispatchListeners = null;
event._dispatchInstances = null;
return res;
}
|
Execution of a "direct" dispatch - there must be at most one dispatch
accumulated on the event or it is considered an error. It doesn't really make
sense for an event with multiple dispatches (bubbled) to keep track of the
return values at each dispatch execution, but it does tend to make sense when
dealing with "direct" dispatches.
@return {*} The return value of executing the single dispatch.
|
executeDirectDispatch
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function hasDispatches(event) {
return !!event._dispatchListeners;
}
|
@param {SyntheticEvent} event
@return {boolean} True iff number of dispatches accumulated is greater than 0.
|
hasDispatches
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function invokeGuardedCallback(name, func, a) {
try {
func(a);
} catch (x) {
if (caughtError === null) {
caughtError = x;
}
}
}
|
Call a function while guarding against errors that happens within it.
@param {String} name of the guard to use for logging or debugging
@param {Function} func The function to invoke
@param {*} a First argument
@param {*} b Second argument
|
invokeGuardedCallback
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function accumulateInto(current, next) {
!(next != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : _prodInvariant('30') : void 0;
if (current == null) {
return next;
}
// Both are not empty. Warning: Never call x.concat(y) when you are not
// certain that x is an Array (x could be a string with concat method).
if (Array.isArray(current)) {
if (Array.isArray(next)) {
current.push.apply(current, next);
return current;
}
current.push(next);
return current;
}
if (Array.isArray(next)) {
// A bit too dangerous to mutate `next`.
return [current].concat(next);
}
return [current, next];
}
|
Accumulates items that must not be null or undefined into the first one. This
is used to conserve memory by avoiding array allocations, and thus sacrifices
API cleanness. Since `current` can be null before being passed in and not
null after this function, make sure to assign it back to `current`:
`a = accumulateInto(a, b);`
This API should be sparingly used. Try `accumulate` for something cleaner.
@return {*|array<*>} An accumulation of items.
|
accumulateInto
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function forEachAccumulated(arr, cb, scope) {
if (Array.isArray(arr)) {
arr.forEach(cb, scope);
} else if (arr) {
cb.call(scope, arr);
}
}
|
@param {array} arr an "accumulation" of items which is either an Array or
a single item. Useful when paired with the `accumulate` module. This is a
simple utility that allows us to reason about a collection of items, but
handling the case when there is exactly one item (and we do not need to
allocate an array).
|
forEachAccumulated
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function FallbackCompositionState(root) {
this._root = root;
this._startText = this.getText();
this._fallbackText = null;
}
|
This helper class stores information about text content of a target node,
allowing comparison of content before and after a given event.
Identify the node where selection currently begins, then observe
both its text content and its current position in the DOM. Since the
browser may natively replace the target node during composition, we can
use its position to find its replacement.
@param {DOMEventTarget} root
|
FallbackCompositionState
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getTextContentAccessor() {
if (!contentKey && ExecutionEnvironment.canUseDOM) {
// Prefer textContent to innerText because many browsers support both but
// SVG <text> elements don't support innerText even when <div> does.
contentKey = 'textContent' in document.documentElement ? 'textContent' : 'innerText';
}
return contentKey;
}
|
Gets the key used to access text content on a DOM node.
@return {?string} Key used to access text content.
@internal
|
getTextContentAccessor
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
|
@param {object} dispatchConfig Configuration used to dispatch this event.
@param {string} dispatchMarker Marker identifying the event target.
@param {object} nativeEvent Native browser event.
@extends {SyntheticUIEvent}
|
SyntheticCompositionEvent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function SyntheticEvent(dispatchConfig, targetInst, nativeEvent, nativeEventTarget) {
if (process.env.NODE_ENV !== 'production') {
// these have a getter/setter for warnings
delete this.nativeEvent;
delete this.preventDefault;
delete this.stopPropagation;
}
this.dispatchConfig = dispatchConfig;
this._targetInst = targetInst;
this.nativeEvent = nativeEvent;
var Interface = this.constructor.Interface;
for (var propName in Interface) {
if (!Interface.hasOwnProperty(propName)) {
continue;
}
if (process.env.NODE_ENV !== 'production') {
delete this[propName]; // this has a getter/setter for warnings
}
var normalize = Interface[propName];
if (normalize) {
this[propName] = normalize(nativeEvent);
} else {
if (propName === 'target') {
this.target = nativeEventTarget;
} else {
this[propName] = nativeEvent[propName];
}
}
}
var defaultPrevented = nativeEvent.defaultPrevented != null ? nativeEvent.defaultPrevented : nativeEvent.returnValue === false;
if (defaultPrevented) {
this.isDefaultPrevented = emptyFunction.thatReturnsTrue;
} else {
this.isDefaultPrevented = emptyFunction.thatReturnsFalse;
}
this.isPropagationStopped = emptyFunction.thatReturnsFalse;
return this;
}
|
Synthetic events are dispatched by event plugins, typically in response to a
top-level event delegation handler.
These systems should generally use pooling to reduce the frequency of garbage
collection. The system should check `isPersistent` to determine whether the
event should be released into the pool after being dispatched. Users that
need a persisted event should invoke `persist`.
Synthetic events (and subclasses) implement the DOM Level 3 Events API by
normalizing browser quirks. Subclasses do not necessarily have to implement a
DOM interface; custom application-specific events can also subclass this.
@param {object} dispatchConfig Configuration used to dispatch this event.
@param {*} targetInst Marker identifying the event target.
@param {object} nativeEvent Native browser event.
@param {DOMEventTarget} nativeEventTarget Target node.
|
SyntheticEvent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getPooledWarningPropertyDefinition(propName, getVal) {
var isFunction = typeof getVal === 'function';
return {
configurable: true,
set: set,
get: get
};
function set(val) {
var action = isFunction ? 'setting the method' : 'setting the property';
warn(action, 'This is effectively a no-op');
return val;
}
function get() {
var action = isFunction ? 'accessing the method' : 'accessing the property';
var result = isFunction ? 'This is a no-op function' : 'This is set to null';
warn(action, result);
return getVal;
}
function warn(action, result) {
var warningCondition = false;
process.env.NODE_ENV !== 'production' ? warning(warningCondition, 'This synthetic event is reused for performance reasons. If you\'re seeing this, ' + 'you\'re %s `%s` on a released/nullified synthetic event. %s. ' + 'If you must keep the original synthetic event around, use event.persist(). ' + 'See https://fb.me/react-event-pooling for more information.', action, propName, result) : void 0;
}
}
|
Helper to nullify syntheticEvent instance properties when destructing
@param {object} SyntheticEvent
@param {String} propName
@return {object} defineProperty object
|
getPooledWarningPropertyDefinition
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function startWatchingForValueChange(target, targetInst) {
activeElement = target;
activeElementInst = targetInst;
activeElementValue = target.value;
activeElementValueProp = Object.getOwnPropertyDescriptor(target.constructor.prototype, 'value');
// Not guarded in a canDefineProperty check: IE8 supports defineProperty only
// on DOM elements
Object.defineProperty(activeElement, 'value', newValueProp);
if (activeElement.attachEvent) {
activeElement.attachEvent('onpropertychange', handlePropertyChange);
} else {
activeElement.addEventListener('propertychange', handlePropertyChange, false);
}
}
|
(For IE <=11) Starts tracking propertychange events on the passed-in element
and override the value property so that we can distinguish user events from
value changes in JS.
|
startWatchingForValueChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function stopWatchingForValueChange() {
if (!activeElement) {
return;
}
// delete restores the original property definition
delete activeElement.value;
if (activeElement.detachEvent) {
activeElement.detachEvent('onpropertychange', handlePropertyChange);
} else {
activeElement.removeEventListener('propertychange', handlePropertyChange, false);
}
activeElement = null;
activeElementInst = null;
activeElementValue = null;
activeElementValueProp = null;
}
|
(For IE <=11) Removes the event listeners from the currently-tracked element,
if any exists.
|
stopWatchingForValueChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function handlePropertyChange(nativeEvent) {
if (nativeEvent.propertyName !== 'value') {
return;
}
var value = nativeEvent.srcElement.value;
if (value === activeElementValue) {
return;
}
activeElementValue = value;
manualDispatchChangeEvent(nativeEvent);
}
|
(For IE <=11) Handles a propertychange event, sending a `change` event if
the value of the active element has changed.
|
handlePropertyChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getTargetInstForInputEvent(topLevelType, targetInst) {
if (topLevelType === 'topInput') {
// In modern browsers (i.e., not IE8 or IE9), the input event is exactly
// what we want so fall through here and trigger an abstract event
return targetInst;
}
}
|
If a `change` event should be fired, returns the target's ID.
|
getTargetInstForInputEvent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function mountOrderComparator(c1, c2) {
return c1._mountOrder - c2._mountOrder;
}
|
Array comparator for ReactComponents by mount ordering.
@param {ReactComponent} c1 first component you're comparing
@param {ReactComponent} c2 second component you're comparing
@return {number} Return value usable by Array.prototype.sort().
|
mountOrderComparator
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function enqueueUpdate(component) {
ensureInjected();
// Various parts of our code (such as ReactCompositeComponent's
// _renderValidatedComponent) assume that calls to render aren't nested;
// verify that that's the case. (This is called by each top-level update
// function, like setState, forceUpdate, etc.; creation and
// destruction of top-level components is guarded in ReactMount.)
if (!batchingStrategy.isBatchingUpdates) {
batchingStrategy.batchedUpdates(enqueueUpdate, component);
return;
}
dirtyComponents.push(component);
if (component._updateBatchNumber == null) {
component._updateBatchNumber = updateBatchNumber + 1;
}
}
|
Mark a component as needing a rerender, adding an optional callback to a
list of functions which will be executed once the rerender occurs.
|
enqueueUpdate
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function asap(callback, context) {
!batchingStrategy.isBatchingUpdates ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context whereupdates are not being batched.') : _prodInvariant('125') : void 0;
asapCallbackQueue.enqueue(callback, context);
asapEnqueued = true;
}
|
Enqueue a callback to be run at the end of the current batching cycle. Throws
if no updates are currently being performed.
|
asap
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function CallbackQueue(arg) {
_classCallCheck(this, CallbackQueue);
this._callbacks = null;
this._contexts = null;
this._arg = arg;
}
|
A specialized pseudo-event module to help keep track of components waiting to
be notified when their DOM representations are available for use.
This implements `PooledClass`, so you should never need to instantiate this.
Instead, use `CallbackQueue.getPooled()`.
@class ReactMountReady
@implements PooledClass
@internal
|
CallbackQueue
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function attachRefs() {
ReactRef.attachRefs(this, this._currentElement);
}
|
Helper to call ReactRef.attachRefs with this composite component, split out
to avoid allocations in the transaction mount-ready queue.
|
attachRefs
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isValidOwner(object) {
return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function');
}
|
@param {?object} object
@return {boolean} True if `object` is a valid owner.
@final
|
isValidOwner
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getEventTarget(nativeEvent) {
var target = nativeEvent.target || nativeEvent.srcElement || window;
// Normalize SVG <use> element events #4963
if (target.correspondingUseElement) {
target = target.correspondingUseElement;
}
// Safari may fire events on text nodes (Node.TEXT_NODE is 3).
// @see http://www.quirksmode.org/js/events_properties.html
return target.nodeType === 3 ? target.parentNode : target;
}
|
Gets the target node from a native browser event by accounting for
inconsistencies in browser DOM APIs.
@param {object} nativeEvent Native browser event.
@return {DOMEventTarget} Target node.
|
getEventTarget
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isTextInputElement(elem) {
var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase();
if (nodeName === 'input') {
return !!supportedInputTypes[elem.type];
}
if (nodeName === 'textarea') {
return true;
}
return false;
}
|
@see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary
|
isTextInputElement
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) {
return SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget);
}
|
@param {object} dispatchConfig Configuration used to dispatch this event.
@param {string} dispatchMarker Marker identifying the event target.
@param {object} nativeEvent Native browser event.
@extends {SyntheticEvent}
|
SyntheticUIEvent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function modifierStateGetter(keyArg) {
var syntheticEvent = this;
var nativeEvent = syntheticEvent.nativeEvent;
if (nativeEvent.getModifierState) {
return nativeEvent.getModifierState(keyArg);
}
var keyProp = modifierKeyToProp[keyArg];
return keyProp ? !!nativeEvent[keyProp] : false;
}
|
Translation from modifier key to the associated property in the event.
@see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers
|
modifierStateGetter
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function insertLazyTreeChildAt(parentNode, childTree, referenceNode) {
DOMLazyTree.insertTreeBefore(parentNode, childTree, referenceNode);
}
|
Inserts `childNode` as a child of `parentNode` at the `index`.
@param {DOMElement} parentNode Parent node in which to insert.
@param {DOMElement} childNode Child node to insert.
@param {number} index Index at which to insert the child.
@internal
|
insertLazyTreeChildAt
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function insertTreeChildren(tree) {
if (!enableLazy) {
return;
}
var node = tree.node;
var children = tree.children;
if (children.length) {
for (var i = 0; i < children.length; i++) {
insertTreeBefore(node, children[i], null);
}
} else if (tree.html != null) {
setInnerHTML(node, tree.html);
} else if (tree.text != null) {
setTextContent(node, tree.text);
}
}
|
In IE (8-11) and Edge, appending nodes with no children is dramatically
faster than appending a full subtree, so we essentially queue up the
.appendChild calls here and apply them so each node is added to its parent
before any children are added.
In other browsers, doing so is slower or neutral compared to the other order
(in Firefox, twice as slow) so we only do this inversion in IE.
See https://github.com/spicyj/innerhtml-vs-createelement-vs-clonenode.
|
insertTreeChildren
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
createMicrosoftUnsafeLocalFunction = function (func) {
if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) {
return function (arg0, arg1, arg2, arg3) {
MSApp.execUnsafeLocalFunction(function () {
return func(arg0, arg1, arg2, arg3);
});
};
} else {
return func;
}
}
|
Create a function which has 'unsafe' privileges (required by windows8 apps)
|
createMicrosoftUnsafeLocalFunction
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
setTextContent = function (node, text) {
if (text) {
var firstChild = node.firstChild;
if (firstChild && firstChild === node.lastChild && firstChild.nodeType === 3) {
firstChild.nodeValue = text;
return;
}
}
node.textContent = text;
}
|
Set the textContent property of a node, ensuring that whitespace is preserved
even in IE8. innerText is a poor substitute for textContent and, among many
issues, inserts <br> instead of the literal newline chars. innerHTML behaves
as it should.
@param {DOMElement} node
@param {string} text
@internal
|
setTextContent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function escapeHtml(string) {
var str = '' + string;
var match = matchHtmlRegExp.exec(str);
if (!match) {
return str;
}
var escape;
var html = '';
var index = 0;
var lastIndex = 0;
for (index = match.index; index < str.length; index++) {
switch (str.charCodeAt(index)) {
case 34:
// "
escape = '"';
break;
case 38:
// &
escape = '&';
break;
case 39:
// '
escape = '''; // modified from escape-html; used to be '''
break;
case 60:
// <
escape = '<';
break;
case 62:
// >
escape = '>';
break;
default:
continue;
}
if (lastIndex !== index) {
html += str.substring(lastIndex, index);
}
lastIndex = index + 1;
html += escape;
}
return lastIndex !== index ? html + str.substring(lastIndex, index) : html;
}
|
Escape special characters in the given string of html.
@param {string} string The string to escape for inserting into HTML
@return {string}
@public
|
escapeHtml
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function escapeTextContentForBrowser(text) {
if (typeof text === 'boolean' || typeof text === 'number') {
// this shortcircuit helps perf for types that we know will never have
// special characters, especially given that this function is used often
// for numeric dom ids.
return '' + text;
}
return escapeHtml(text);
}
|
Escapes text to prevent scripting attacks.
@param {*} text Text value to escape.
@return {string} An escaped string.
|
escapeTextContentForBrowser
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getNodeName(markup) {
var nodeNameMatch = markup.match(nodeNamePattern);
return nodeNameMatch && nodeNameMatch[1].toLowerCase();
}
|
Extracts the `nodeName` of the first element in a string of markup.
@param {string} markup String of markup.
@return {?string} Node name of the supplied markup.
|
getNodeName
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function createNodesFromMarkup(markup, handleScript) {
var node = dummyNode;
!!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : void 0;
var nodeName = getNodeName(markup);
var wrap = nodeName && getMarkupWrap(nodeName);
if (wrap) {
node.innerHTML = wrap[1] + markup + wrap[2];
var wrapDepth = wrap[0];
while (wrapDepth--) {
node = node.lastChild;
}
} else {
node.innerHTML = markup;
}
var scripts = node.getElementsByTagName('script');
if (scripts.length) {
!handleScript ? process.env.NODE_ENV !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : void 0;
createArrayFromMixed(scripts).forEach(handleScript);
}
var nodes = Array.from(node.childNodes);
while (node.lastChild) {
node.removeChild(node.lastChild);
}
return nodes;
}
|
Creates an array containing the nodes rendered from the supplied markup. The
optionally supplied `handleScript` function will be invoked once for each
<script> element that is rendered. If no `handleScript` function is supplied,
an exception is thrown if any <script> elements are rendered.
@param {string} markup A string of valid HTML markup.
@param {?function} handleScript Invoked once for each rendered <script>.
@return {array<DOMElement|DOMTextNode>} An array of rendered nodes.
|
createNodesFromMarkup
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function toArray(obj) {
var length = obj.length;
// Some browsers builtin objects can report typeof 'function' (e.g. NodeList
// in old versions of Safari).
!(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : void 0;
!(typeof length === 'number') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : void 0;
!(length === 0 || length - 1 in obj) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : void 0;
!(typeof obj.callee !== 'function') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'toArray: Object can\'t be `arguments`. Use rest params ' + '(function(...args) {}) or Array.from() instead.') : invariant(false) : void 0;
// Old IE doesn't give collections access to hasOwnProperty. Assume inputs
// without method will throw during the slice call and skip straight to the
// fallback.
if (obj.hasOwnProperty) {
try {
return Array.prototype.slice.call(obj);
} catch (e) {
// IE < 9 does not support Array#slice on collections objects
}
}
// Fall back to copying key by key. This assumes all keys have a value,
// so will not preserve sparsely populated inputs.
var ret = Array(length);
for (var ii = 0; ii < length; ii++) {
ret[ii] = obj[ii];
}
return ret;
}
|
Convert array-like objects to arrays.
This API assumes the caller knows the contents of the data type. For less
well defined inputs use createArrayFromMixed.
@param {object|function|filelist} obj
@return {array}
|
toArray
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function hasArrayNature(obj) {
return (
// not null/false
!!obj && (
// arrays are objects, NodeLists are functions in Safari
typeof obj == 'object' || typeof obj == 'function') &&
// quacks like an array
'length' in obj &&
// not window
!('setInterval' in obj) &&
// no DOM node should be considered an array-like
// a 'select' element has 'length' and 'item' properties on IE8
typeof obj.nodeType != 'number' && (
// a real array
Array.isArray(obj) ||
// arguments
'callee' in obj ||
// HTMLCollection/NodeList
'item' in obj)
);
}
|
Perform a heuristic test to determine if an object is "array-like".
A monk asked Joshu, a Zen master, "Has a dog Buddha nature?"
Joshu replied: "Mu."
This function determines if its argument has "array nature": it returns
true if the argument is an actual array, an `arguments' object, or an
HTMLCollection (e.g. node.childNodes or node.getElementsByTagName()).
It will return false for other array-like objects like Filelist.
@param {*} obj
@return {boolean}
|
hasArrayNature
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function createArrayFromMixed(obj) {
if (!hasArrayNature(obj)) {
return [obj];
} else if (Array.isArray(obj)) {
return obj.slice();
} else {
return toArray(obj);
}
}
|
Ensure that the argument is an array by wrapping it in an array if it is not.
Creates a copy of the argument if it is already an array.
This is mostly useful idiomatically:
var createArrayFromMixed = require('createArrayFromMixed');
function takesOneOrMoreThings(things) {
things = createArrayFromMixed(things);
...
}
This allows you to treat `things' as an array, but accept scalars in the API.
If you need to convert an array-like object, like `arguments`, into an array
use toArray instead.
@param {*} obj
@return {array}
|
createArrayFromMixed
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getMarkupWrap(nodeName) {
!!!dummyNode ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : void 0;
if (!markupWrap.hasOwnProperty(nodeName)) {
nodeName = '*';
}
if (!shouldWrap.hasOwnProperty(nodeName)) {
if (nodeName === '*') {
dummyNode.innerHTML = '<link />';
} else {
dummyNode.innerHTML = '<' + nodeName + '></' + nodeName + '>';
}
shouldWrap[nodeName] = !dummyNode.firstChild;
}
return shouldWrap[nodeName] ? markupWrap[nodeName] : null;
}
|
Gets the markup wrap configuration for the supplied `nodeName`.
NOTE: This lazily detects which wraps are necessary for the current browser.
@param {string} nodeName Lowercase `nodeName`.
@return {?array} Markup wrap configuration, if applicable.
|
getMarkupWrap
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function assertValidProps(component, props) {
if (!props) {
return;
}
// Note the use of `==` which checks for null or undefined.
if (voidElementTags[component._tag]) {
!(props.children == null && props.dangerouslySetInnerHTML == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, '%s is a void element tag and must neither have `children` nor use `dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : _prodInvariant('137', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : void 0;
}
if (props.dangerouslySetInnerHTML != null) {
!(props.children == null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : _prodInvariant('60') : void 0;
!(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? process.env.NODE_ENV !== 'production' ? invariant(false, '`props.dangerouslySetInnerHTML` must be in the form `{__html: ...}`. Please visit https://fb.me/react-invariant-dangerously-set-inner-html for more information.') : _prodInvariant('61') : void 0;
}
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : void 0;
process.env.NODE_ENV !== 'production' ? warning(props.suppressContentEditableWarning || !props.contentEditable || props.children == null, 'A component is `contentEditable` and contains `children` managed by ' + 'React. It is now your responsibility to guarantee that none of ' + 'those nodes are unexpectedly modified or duplicated. This is ' + 'probably not intentional.') : void 0;
process.env.NODE_ENV !== 'production' ? warning(props.onFocusIn == null && props.onFocusOut == null, 'React uses onFocus and onBlur instead of onFocusIn and onFocusOut. ' + 'All React events are normalized to bubble, so onFocusIn and onFocusOut ' + 'are not needed/supported by React.') : void 0;
}
!(props.style == null || typeof props.style === 'object') ? process.env.NODE_ENV !== 'production' ? invariant(false, 'The `style` prop expects a mapping from style properties to values, not a string. For example, style={{marginRight: spacing + \'em\'}} when using JSX.%s', getDeclarationErrorAddendum(component)) : _prodInvariant('62', getDeclarationErrorAddendum(component)) : void 0;
}
|
@param {object} component
@param {?object} props
|
assertValidProps
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function ReactDOMComponent(element) {
var tag = element.type;
validateDangerousTag(tag);
this._currentElement = element;
this._tag = tag.toLowerCase();
this._namespaceURI = null;
this._renderedChildren = null;
this._previousStyle = null;
this._previousStyleCopy = null;
this._hostNode = null;
this._hostParent = null;
this._rootNodeID = 0;
this._domID = 0;
this._hostContainerInfo = null;
this._wrapperState = null;
this._topLevelWrapper = null;
this._flags = 0;
if (process.env.NODE_ENV !== 'production') {
this._ancestorInfo = null;
setAndValidateContentChildDev.call(this, null);
}
}
|
Creates a new React class that is idempotent and capable of containing other
React components. It accepts event listeners and DOM properties that are
valid according to `DOMProperty`.
- Event listeners: `onClick`, `onMouseDown`, etc.
- DOM properties: `className`, `name`, `title`, etc.
The `style` property functions differently from the DOM API. It accepts an
object mapping of style properties to values.
@constructor ReactDOMComponent
@extends ReactMultiChild
|
ReactDOMComponent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function focusNode(node) {
// IE8 can throw "Can't move focus to the control because it is invisible,
// not enabled, or of a type that does not accept the focus." for all kinds of
// reasons that are too expensive and fragile to test.
try {
node.focus();
} catch (e) {}
}
|
@param {DOMElement} node input/textarea to focus
|
focusNode
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
warnValidStyle = function (name, value, component) {
var owner;
if (component) {
owner = component._currentElement._owner;
}
if (name.indexOf('-') > -1) {
warnHyphenatedStyleName(name, owner);
} else if (badVendoredStyleNamePattern.test(name)) {
warnBadVendoredStyleName(name, owner);
} else if (badStyleValueWithSemicolonPattern.test(value)) {
warnStyleValueWithSemicolon(name, value, owner);
}
if (typeof value === 'number' && isNaN(value)) {
warnStyleValueIsNaN(name, value, owner);
}
}
|
@param {string} name
@param {*} value
@param {ReactDOMComponent} component
|
warnValidStyle
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function prefixKey(prefix, key) {
return prefix + key.charAt(0).toUpperCase() + key.substring(1);
}
|
@param {string} prefix vendor-specific prefix, eg: Webkit
@param {string} key style name, eg: transitionDuration
@return {string} style name prefixed with `prefix`, properly camelCased, eg:
WebkitTransitionDuration
|
prefixKey
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function camelize(string) {
return string.replace(_hyphenPattern, function (_, character) {
return character.toUpperCase();
});
}
|
Camelcases a hyphenated string, for example:
> camelize('background-color')
< "backgroundColor"
@param {string} string
@return {string}
|
camelize
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function dangerousStyleValue(name, value, component) {
// Note that we've removed escapeTextForBrowser() calls here since the
// whole string will be escaped when the attribute is injected into
// the markup. If you provide unsafe user data here they can inject
// arbitrary CSS which may be problematic (I couldn't repro this):
// https://www.owasp.org/index.php/XSS_Filter_Evasion_Cheat_Sheet
// http://www.thespanner.co.uk/2007/11/26/ultimate-xss-css-injection/
// This is not an XSS hole but instead a potential CSS injection issue
// which has lead to a greater discussion about how we're going to
// trust URLs moving forward. See #2115901
var isEmpty = value == null || typeof value === 'boolean' || value === '';
if (isEmpty) {
return '';
}
var isNonNumeric = isNaN(value);
if (isNonNumeric || value === 0 || isUnitlessNumber.hasOwnProperty(name) && isUnitlessNumber[name]) {
return '' + value; // cast to string
}
if (typeof value === 'string') {
if (process.env.NODE_ENV !== 'production') {
// Allow '0' to pass through without warning. 0 is already special and
// doesn't require units, so we don't need to warn about it.
if (component && value !== '0') {
var owner = component._currentElement._owner;
var ownerName = owner ? owner.getName() : null;
if (ownerName && !styleWarnings[ownerName]) {
styleWarnings[ownerName] = {};
}
var warned = false;
if (ownerName) {
var warnings = styleWarnings[ownerName];
warned = warnings[name];
if (!warned) {
warnings[name] = true;
}
}
if (!warned) {
process.env.NODE_ENV !== 'production' ? warning(false, 'a `%s` tag (owner: `%s`) was passed a numeric string value ' + 'for CSS property `%s` (value: `%s`) which will be treated ' + 'as a unitless number in a future version of React.', component._currentElement.type, ownerName || 'unknown', name, value) : void 0;
}
}
}
value = value.trim();
}
return value + 'px';
}
|
Convert a value into the proper css writable value. The style name `name`
should be logical (no hyphens), as specified
in `CSSProperty.isUnitlessNumber`.
@param {string} name CSS property name such as `topMargin`.
@param {*} value CSS property value such as `10px`.
@param {ReactDOMComponent} component
@return {string} Normalized style value with dimensions applied.
|
dangerousStyleValue
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function hyphenateStyleName(string) {
return hyphenate(string).replace(msPattern, '-ms-');
}
|
Hyphenates a camelcased CSS property name, for example:
> hyphenateStyleName('backgroundColor')
< "background-color"
> hyphenateStyleName('MozTransition')
< "-moz-transition"
> hyphenateStyleName('msTransition')
< "-ms-transition"
As Modernizr suggests (http://modernizr.com/docs/#prefixed), an `ms` prefix
is converted to `-ms-`.
@param {string} string
@return {string}
|
hyphenateStyleName
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function hyphenate(string) {
return string.replace(_uppercasePattern, '-$1').toLowerCase();
}
|
Hyphenates a camelcased string, for example:
> hyphenate('backgroundColor')
< "background-color"
For CSS style names, use `hyphenateStyleName` instead which works properly
with all vendor prefixes, including `ms`.
@param {string} string
@return {string}
|
hyphenate
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function memoizeStringOnly(callback) {
var cache = {};
return function (string) {
if (!cache.hasOwnProperty(string)) {
cache[string] = callback.call(this, string);
}
return cache[string];
};
}
|
Memoizes the return value of a function that accepts one string argument.
|
memoizeStringOnly
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function quoteAttributeValueForBrowser(value) {
return '"' + escapeTextContentForBrowser(value) + '"';
}
|
Escapes attribute value to prevent scripting attacks.
@param {*} value Value to escape.
@return {string} An escaped string.
|
quoteAttributeValueForBrowser
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getListeningForDocument(mountAt) {
// In IE8, `mountAt` is a host object and doesn't have `hasOwnProperty`
// directly.
if (!Object.prototype.hasOwnProperty.call(mountAt, topListenersIDKey)) {
mountAt[topListenersIDKey] = reactTopListenersCounter++;
alreadyListeningTo[mountAt[topListenersIDKey]] = {};
}
return alreadyListeningTo[mountAt[topListenersIDKey]];
}
|
To ensure no conflicts with other potential React instances on the page
|
getListeningForDocument
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makePrefixMap(styleProp, eventName) {
var prefixes = {};
prefixes[styleProp.toLowerCase()] = eventName.toLowerCase();
prefixes['Webkit' + styleProp] = 'webkit' + eventName;
prefixes['Moz' + styleProp] = 'moz' + eventName;
prefixes['ms' + styleProp] = 'MS' + eventName;
prefixes['O' + styleProp] = 'o' + eventName.toLowerCase();
return prefixes;
}
|
Generate a mapping of standard vendor prefixes using the defined style property and event name.
@param {string} styleProp
@param {string} eventName
@returns {object}
|
makePrefixMap
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getVendorPrefixedEventName(eventName) {
if (prefixedEventNames[eventName]) {
return prefixedEventNames[eventName];
} else if (!vendorPrefixes[eventName]) {
return eventName;
}
var prefixMap = vendorPrefixes[eventName];
for (var styleProp in prefixMap) {
if (prefixMap.hasOwnProperty(styleProp) && styleProp in style) {
return prefixedEventNames[eventName] = prefixMap[styleProp];
}
}
return '';
}
|
Attempts to determine the correct vendor prefixed event name.
@param {string} eventName
@returns {string}
|
getVendorPrefixedEventName
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
// Here we use asap to wait until all updates have propagated, which
// is important when using controlled components within layers:
// https://github.com/facebook/react/issues/1698
ReactUpdates.asap(forceUpdateIfMounted, this);
var name = props.name;
if (props.type === 'radio' && name != null) {
var rootNode = ReactDOMComponentTree.getNodeFromInstance(this);
var queryRoot = rootNode;
while (queryRoot.parentNode) {
queryRoot = queryRoot.parentNode;
}
// If `rootNode.form` was non-null, then we could try `form.elements`,
// but that sometimes behaves strangely in IE8. We could also try using
// `form.getElementsByName`, but that will only return direct children
// and won't include inputs that use the HTML5 `form=` attribute. Since
// the input might not even be in a form, let's just use the global
// `querySelectorAll` to ensure we don't miss anything.
var group = queryRoot.querySelectorAll('input[name=' + JSON.stringify('' + name) + '][type="radio"]');
for (var i = 0; i < group.length; i++) {
var otherNode = group[i];
if (otherNode === rootNode || otherNode.form !== rootNode.form) {
continue;
}
// This will throw if radio buttons rendered by different copies of React
// and the same name are rendered into the same form (same as #1939).
// That's probably okay; we don't support it just as we don't support
// mixing React radio buttons with non-React ones.
var otherInstance = ReactDOMComponentTree.getInstanceFromNode(otherNode);
!otherInstance ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the same `name` is not supported.') : _prodInvariant('90') : void 0;
// If this is a controlled radio button group, forcing the input that
// was previously checked to update will cause it to be come re-checked
// as appropriate.
ReactUpdates.asap(forceUpdateIfMounted, otherInstance);
}
}
return returnValue;
}
|
Implements an <input> host component that allows setting these optional
props: `checked`, `value`, `defaultChecked`, and `defaultValue`.
If `checked` or `value` are not supplied (or null/undefined), user actions
that affect the checked state or value will trigger updates to the element.
If they are supplied (and not null/undefined), the rendered element will not
trigger updates to the element. Instead, the props must change in order for
the rendered element to be updated.
The rendered element will be initialized as unchecked (or `defaultChecked`)
with an empty value (or `defaultValue`).
@see http://www.w3.org/TR/2012/WD-html5-20121025/the-input-element.html
|
_handleChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function checkSelectPropTypes(inst, props) {
var owner = inst._currentElement._owner;
LinkedValueUtils.checkPropTypes('select', props, owner);
if (props.valueLink !== undefined && !didWarnValueLink) {
process.env.NODE_ENV !== 'production' ? warning(false, '`valueLink` prop on `select` is deprecated; set `value` and `onChange` instead.') : void 0;
didWarnValueLink = true;
}
for (var i = 0; i < valuePropNames.length; i++) {
var propName = valuePropNames[i];
if (props[propName] == null) {
continue;
}
var isArray = Array.isArray(props[propName]);
if (props.multiple && !isArray) {
process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
} else if (!props.multiple && isArray) {
process.env.NODE_ENV !== 'production' ? warning(false, 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : void 0;
}
}
}
|
Validation function for `value` and `defaultValue`.
@private
|
checkSelectPropTypes
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function updateOptions(inst, multiple, propValue) {
var selectedValue, i;
var options = ReactDOMComponentTree.getNodeFromInstance(inst).options;
if (multiple) {
selectedValue = {};
for (i = 0; i < propValue.length; i++) {
selectedValue['' + propValue[i]] = true;
}
for (i = 0; i < options.length; i++) {
var selected = selectedValue.hasOwnProperty(options[i].value);
if (options[i].selected !== selected) {
options[i].selected = selected;
}
}
} else {
// Do not set `select.value` as exact behavior isn't consistent across all
// browsers for all cases.
selectedValue = '' + propValue;
for (i = 0; i < options.length; i++) {
if (options[i].value === selectedValue) {
options[i].selected = true;
return;
}
}
if (options.length) {
options[0].selected = true;
}
}
}
|
@param {ReactDOMComponent} inst
@param {boolean} multiple
@param {*} propValue A stringable (with `multiple`, a list of stringables).
@private
|
updateOptions
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
if (this._rootNodeID) {
this._wrapperState.pendingUpdate = true;
}
ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this);
return returnValue;
}
|
Implements a <select> host component that allows optionally setting the
props `value` and `defaultValue`. If `multiple` is false, the prop must be a
stringable. If `multiple` is true, the prop must be an array of stringables.
If `value` is not supplied (or null/undefined), user actions that change the
selected option will trigger updates to the rendered options.
If it is supplied (and not null/undefined), the rendered options will not
update in response to user actions. Instead, the `value` prop must change in
order for the rendered options to update.
If `defaultValue` is provided, any options with the supplied values will be
selected.
|
_handleChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function _handleChange(event) {
var props = this._currentElement.props;
var returnValue = LinkedValueUtils.executeOnChange(props, event);
ReactUpdates.asap(forceUpdateIfMounted, this);
return returnValue;
}
|
Implements a <textarea> host component that allows setting `value`, and
`defaultValue`. This differs from the traditional DOM API because value is
usually set as PCDATA children.
If `value` is not supplied (or null/undefined), user actions that affect the
value will trigger updates to the element.
If `value` is supplied (and not null/undefined), the rendered element will
not trigger updates to the element. Instead, the `value` prop must change in
order for the rendered element to be updated.
The rendered element will be initialized with an empty value, the prop
`defaultValue` if specified, or the children content (deprecated).
|
_handleChange
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makeInsertMarkup(markup, afterNode, toIndex) {
// NOTE: Null values reduce hidden classes.
return {
type: 'INSERT_MARKUP',
content: markup,
fromIndex: null,
fromNode: null,
toIndex: toIndex,
afterNode: afterNode
};
}
|
Make an update for markup to be rendered and inserted at a supplied index.
@param {string} markup Markup that renders into an element.
@param {number} toIndex Destination index.
@private
|
makeInsertMarkup
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makeMove(child, afterNode, toIndex) {
// NOTE: Null values reduce hidden classes.
return {
type: 'MOVE_EXISTING',
content: null,
fromIndex: child._mountIndex,
fromNode: ReactReconciler.getHostNode(child),
toIndex: toIndex,
afterNode: afterNode
};
}
|
Make an update for moving an existing element to another index.
@param {number} fromIndex Source index of the existing element.
@param {number} toIndex Destination index of the element.
@private
|
makeMove
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makeRemove(child, node) {
// NOTE: Null values reduce hidden classes.
return {
type: 'REMOVE_NODE',
content: null,
fromIndex: child._mountIndex,
fromNode: node,
toIndex: null,
afterNode: null
};
}
|
Make an update for removing an element at an index.
@param {number} fromIndex Index of the element to remove.
@private
|
makeRemove
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makeSetMarkup(markup) {
// NOTE: Null values reduce hidden classes.
return {
type: 'SET_MARKUP',
content: markup,
fromIndex: null,
fromNode: null,
toIndex: null,
afterNode: null
};
}
|
Make an update for setting the markup of a node.
@param {string} markup Markup that renders into an element.
@private
|
makeSetMarkup
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function makeTextContent(textContent) {
// NOTE: Null values reduce hidden classes.
return {
type: 'TEXT_CONTENT',
content: textContent,
fromIndex: null,
fromNode: null,
toIndex: null,
afterNode: null
};
}
|
Make an update for setting the text content.
@param {string} textContent Text content to set.
@private
|
makeTextContent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function enqueue(queue, update) {
if (update) {
queue = queue || [];
queue.push(update);
}
return queue;
}
|
Push an update, if any, onto the queue. Creates a new queue if none is
passed and always returns the queue. Mutative.
|
enqueue
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isInternalComponentType(type) {
return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function';
}
|
Check if the type reference is a known internal type. I.e. not a user
provided composite type.
@param {function} type
@return {boolean} Returns true if this is a valid internal type.
|
isInternalComponentType
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function instantiateReactComponent(node, shouldHaveDebugID) {
var instance;
if (node === null || node === false) {
instance = ReactEmptyComponent.create(instantiateReactComponent);
} else if (typeof node === 'object') {
var element = node;
var type = element.type;
if (typeof type !== 'function' && typeof type !== 'string') {
var info = '';
if (process.env.NODE_ENV !== 'production') {
if (type === undefined || typeof type === 'object' && type !== null && Object.keys(type).length === 0) {
info += ' You likely forgot to export your component from the file ' + 'it\'s defined in.';
}
}
info += getDeclarationErrorAddendum(element._owner);
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Element type is invalid: expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s', type == null ? type : typeof type, info) : _prodInvariant('130', type == null ? type : typeof type, info) : void 0;
}
// Special case string values
if (typeof element.type === 'string') {
instance = ReactHostComponent.createInternalComponent(element);
} else if (isInternalComponentType(element.type)) {
// This is temporarily available for custom components that are not string
// representations. I.e. ART. Once those are updated to use the string
// representation, we can drop this code path.
instance = new element.type(element);
// We renamed this. Allow the old name for compat. :(
if (!instance.getHostNode) {
instance.getHostNode = instance.getNativeNode;
}
} else {
instance = new ReactCompositeComponentWrapper(element);
}
} else if (typeof node === 'string' || typeof node === 'number') {
instance = ReactHostComponent.createInstanceForText(node);
} else {
true ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : _prodInvariant('131', typeof node) : void 0;
}
if (process.env.NODE_ENV !== 'production') {
process.env.NODE_ENV !== 'production' ? warning(typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.getHostNode === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : void 0;
}
// These two fields are used by the DOM and ART diffing algorithms
// respectively. Instead of using expandos on components, we should be
// storing the state needed by the diffing algorithms elsewhere.
instance._mountIndex = 0;
instance._mountImage = null;
if (process.env.NODE_ENV !== 'production') {
instance._debugID = shouldHaveDebugID ? getNextDebugID() : 0;
}
// Internal instances should fully constructed at this point, so they should
// not get any new fields added to them at this point.
if (process.env.NODE_ENV !== 'production') {
if (Object.preventExtensions) {
Object.preventExtensions(instance);
}
}
return instance;
}
|
Given a ReactNode, create an instance that will actually be mounted.
@param {ReactNode} node
@param {boolean} shouldHaveDebugID
@return {object} A new instance of the element's constructor.
@protected
|
instantiateReactComponent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function shallowEqual(objA, objB) {
if (is(objA, objB)) {
return true;
}
if (typeof objA !== 'object' || objA === null || typeof objB !== 'object' || objB === null) {
return false;
}
var keysA = Object.keys(objA);
var keysB = Object.keys(objB);
if (keysA.length !== keysB.length) {
return false;
}
// Test for A's keys different from B.
for (var i = 0; i < keysA.length; i++) {
if (!hasOwnProperty.call(objB, keysA[i]) || !is(objA[keysA[i]], objB[keysA[i]])) {
return false;
}
}
return true;
}
|
Performs equality by iterating through keys on an object and returning false
when any key has values which are not strictly equal between the arguments.
Returns true when the values of all keys are strictly equal.
|
shallowEqual
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function shouldUpdateReactComponent(prevElement, nextElement) {
var prevEmpty = prevElement === null || prevElement === false;
var nextEmpty = nextElement === null || nextElement === false;
if (prevEmpty || nextEmpty) {
return prevEmpty === nextEmpty;
}
var prevType = typeof prevElement;
var nextType = typeof nextElement;
if (prevType === 'string' || prevType === 'number') {
return nextType === 'string' || nextType === 'number';
} else {
return nextType === 'object' && prevElement.type === nextElement.type && prevElement.key === nextElement.key;
}
}
|
Given a `prevElement` and `nextElement`, determines if the existing
instance should be updated as opposed to being destroyed or replaced by a new
instance. Both arguments are elements. This ensures that this logic can
operate on stateless trees without any backing instance.
@param {?object} prevElement
@param {?object} nextElement
@return {boolean} True if the existing instance should be updated.
@protected
|
shouldUpdateReactComponent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function createInternalComponent(element) {
!genericComponentClass ? process.env.NODE_ENV !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : _prodInvariant('111', element.type) : void 0;
return new genericComponentClass(element);
}
|
Get a host internal component class for a specific tag.
@param {ReactElement} element The element to create.
@return {function} The internal class constructor function.
|
createInternalComponent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID) {
// We found a component instance.
if (traverseContext && typeof traverseContext === 'object') {
var result = traverseContext;
var keyUnique = result[name] === undefined;
if (process.env.NODE_ENV !== 'production') {
if (!ReactComponentTreeHook) {
ReactComponentTreeHook = __webpack_require__(28);
}
if (!keyUnique) {
process.env.NODE_ENV !== 'production' ? warning(false, 'flattenChildren(...): Encountered two children with the same key, ' + '`%s`. Child keys must be unique; when two children share a key, only ' + 'the first child will be used.%s', KeyEscapeUtils.unescape(name), ReactComponentTreeHook.getStackAddendumByID(selfDebugID)) : void 0;
}
}
if (keyUnique && child != null) {
result[name] = child;
}
}
}
|
@param {function} traverseContext Context passed through traversal.
@param {?ReactComponent} child React child component.
@param {!string} name String name of key path to child.
@param {number=} selfDebugID Optional debugID of the current internal instance.
|
flattenSingleChildIntoContext
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function flattenChildren(children, selfDebugID) {
if (children == null) {
return children;
}
var result = {};
if (process.env.NODE_ENV !== 'production') {
traverseAllChildren(children, function (traverseContext, child, name) {
return flattenSingleChildIntoContext(traverseContext, child, name, selfDebugID);
}, result);
} else {
traverseAllChildren(children, flattenSingleChildIntoContext, result);
}
return result;
}
|
Flattens children that are typically specified as `props.children`. Any null
children will not be included in the resulting object.
@return {!object} flattened children keyed by name.
|
flattenChildren
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function ReactServerUpdateQueue(transaction) {
_classCallCheck(this, ReactServerUpdateQueue);
this.transaction = transaction;
}
|
This is the update queue used for server rendering.
It delegates to ReactUpdateQueue while server rendering is in progress and
switches to ReactNoopUpdateQueue after the transaction has completed.
@class ReactServerUpdateQueue
@param {Transaction} transaction
|
ReactServerUpdateQueue
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
findOwnerStack = function (instance) {
if (!instance) {
return [];
}
var stack = [];
do {
stack.push(instance);
} while (instance = instance._currentElement._owner);
stack.reverse();
return stack;
}
|
Given a ReactCompositeComponent instance, return a list of its recursive
owners, starting at the root and ending with the instance itself.
|
findOwnerStack
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getLowestCommonAncestor(instA, instB) {
!('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
!('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getNodeFromInstance: Invalid argument.') : _prodInvariant('33') : void 0;
var depthA = 0;
for (var tempA = instA; tempA; tempA = tempA._hostParent) {
depthA++;
}
var depthB = 0;
for (var tempB = instB; tempB; tempB = tempB._hostParent) {
depthB++;
}
// If A is deeper, crawl up.
while (depthA - depthB > 0) {
instA = instA._hostParent;
depthA--;
}
// If B is deeper, crawl up.
while (depthB - depthA > 0) {
instB = instB._hostParent;
depthB--;
}
// Walk in lockstep until we find a match.
var depth = depthA;
while (depth--) {
if (instA === instB) {
return instA;
}
instA = instA._hostParent;
instB = instB._hostParent;
}
return null;
}
|
Return the lowest common ancestor of A and B, or null if they are in
different trees.
|
getLowestCommonAncestor
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isAncestor(instA, instB) {
!('_hostNode' in instA) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
!('_hostNode' in instB) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'isAncestor: Invalid argument.') : _prodInvariant('35') : void 0;
while (instB) {
if (instB === instA) {
return true;
}
instB = instB._hostParent;
}
return false;
}
|
Return if A is an ancestor of B.
|
isAncestor
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getParentInstance(inst) {
!('_hostNode' in inst) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'getParentInstance: Invalid argument.') : _prodInvariant('36') : void 0;
return inst._hostParent;
}
|
Return the parent instance of the passed-in instance.
|
getParentInstance
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function traverseTwoPhase(inst, fn, arg) {
var path = [];
while (inst) {
path.push(inst);
inst = inst._hostParent;
}
var i;
for (i = path.length; i-- > 0;) {
fn(path[i], 'captured', arg);
}
for (i = 0; i < path.length; i++) {
fn(path[i], 'bubbled', arg);
}
}
|
Simulates the traversal of a two-phase, capture/bubble event dispatch.
|
traverseTwoPhase
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function traverseEnterLeave(from, to, fn, argFrom, argTo) {
var common = from && to ? getLowestCommonAncestor(from, to) : null;
var pathFrom = [];
while (from && from !== common) {
pathFrom.push(from);
from = from._hostParent;
}
var pathTo = [];
while (to && to !== common) {
pathTo.push(to);
to = to._hostParent;
}
var i;
for (i = 0; i < pathFrom.length; i++) {
fn(pathFrom[i], 'bubbled', argFrom);
}
for (i = pathTo.length; i-- > 0;) {
fn(pathTo[i], 'captured', argTo);
}
}
|
Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that
should would receive a `mouseEnter` or `mouseLeave` event.
Does not invoke the callback on the nearest common ancestor because nothing
"entered" or "left" that element.
|
traverseEnterLeave
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
ReactDOMTextComponent = function (text) {
// TODO: This is really a ReactText (ReactNode), not a ReactElement
this._currentElement = text;
this._stringText = '' + text;
// ReactDOMComponentTree uses these:
this._hostNode = null;
this._hostParent = null;
// Properties
this._domID = 0;
this._mountIndex = 0;
this._closingComment = null;
this._commentNodes = null;
}
|
Text nodes violate a couple assumptions that React makes about components:
- When mounting text into the DOM, adjacent text nodes are merged.
- Text nodes cannot be assigned a React root ID.
This component is used to wrap strings between comment nodes so that they
can undergo the same reconciliation that is applied to elements.
TODO: Investigate representing React components in the DOM with text nodes.
@class ReactDOMTextComponent
@extends ReactComponent
@internal
|
ReactDOMTextComponent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function findParent(inst) {
// TODO: It may be a good idea to cache this to prevent unnecessary DOM
// traversal, but caching is difficult to do correctly without using a
// mutation observer to listen for all DOM changes.
while (inst._hostParent) {
inst = inst._hostParent;
}
var rootNode = ReactDOMComponentTree.getNodeFromInstance(inst);
var container = rootNode.parentNode;
return ReactDOMComponentTree.getClosestInstanceFromNode(container);
}
|
Find the deepest React component completely containing the root of the
passed-in instance (for use when entire React trees are nested within each
other). If React trees are not nested, returns null.
|
findParent
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getUnboundedScrollPosition(scrollable) {
if (scrollable === window) {
return {
x: window.pageXOffset || document.documentElement.scrollLeft,
y: window.pageYOffset || document.documentElement.scrollTop
};
}
return {
x: scrollable.scrollLeft,
y: scrollable.scrollTop
};
}
|
Gets the scroll position of the supplied element or window.
The return values are unbounded, unlike `getScrollPosition`. This means they
may be negative or exceed the element boundaries (which is possible using
inertial scrolling).
@param {DOMWindow|DOMElement} scrollable
@return {object} Map with `x` and `y` keys.
|
getUnboundedScrollPosition
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function ReactReconcileTransaction(useCreateElement) {
this.reinitializeTransaction();
// Only server-side rendering really needs this option (see
// `ReactServerRendering`), but server-side uses
// `ReactServerRenderingTransaction` instead. This option is here so that it's
// accessible and defaults to false when `ReactDOMComponent` and
// `ReactDOMTextComponent` checks it in `mountComponent`.`
this.renderToStaticMarkup = false;
this.reactMountReady = CallbackQueue.getPooled(null);
this.useCreateElement = useCreateElement;
}
|
Currently:
- The order that these are listed in the transaction is critical:
- Suppresses events.
- Restores selection range.
Future:
- Restore document/overflow scroll positions that were unintentionally
modified via DOM insertions above the top viewport boundary.
- Implement/integrate with customized constraint based layout system and keep
track of which dimensions must be remeasured.
@class ReactReconcileTransaction
|
ReactReconcileTransaction
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) {
return anchorNode === focusNode && anchorOffset === focusOffset;
}
|
While `isCollapsed` is available on the Selection object and `collapsed`
is available on the Range object, IE11 sometimes gets them wrong.
If the anchor/focus nodes and offsets are the same, the range is collapsed.
|
isCollapsed
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getIEOffsets(node) {
var selection = document.selection;
var selectedRange = selection.createRange();
var selectedLength = selectedRange.text.length;
// Duplicate selection so we can move range without breaking user selection.
var fromStart = selectedRange.duplicate();
fromStart.moveToElementText(node);
fromStart.setEndPoint('EndToStart', selectedRange);
var startOffset = fromStart.text.length;
var endOffset = startOffset + selectedLength;
return {
start: startOffset,
end: endOffset
};
}
|
Get the appropriate anchor and focus node/offset pairs for IE.
The catch here is that IE's selection API doesn't provide information
about whether the selection is forward or backward, so we have to
behave as though it's always forward.
IE text differs from modern selection in that it behaves as though
block elements end with a new line. This means character offsets will
differ between the two APIs.
@param {DOMElement} node
@return {object}
|
getIEOffsets
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function setIEOffsets(node, offsets) {
var range = document.selection.createRange().duplicate();
var start, end;
if (offsets.end === undefined) {
start = offsets.start;
end = start;
} else if (offsets.start > offsets.end) {
start = offsets.end;
end = offsets.start;
} else {
start = offsets.start;
end = offsets.end;
}
range.moveToElementText(node);
range.moveStart('character', start);
range.setEndPoint('EndToStart', range);
range.moveEnd('character', end - start);
range.select();
}
|
@param {DOMElement|DOMTextNode} node
@param {object} offsets
|
setIEOffsets
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function setModernOffsets(node, offsets) {
if (!window.getSelection) {
return;
}
var selection = window.getSelection();
var length = node[getTextContentAccessor()].length;
var start = Math.min(offsets.start, length);
var end = offsets.end === undefined ? start : Math.min(offsets.end, length);
// IE 11 uses modern selection, but doesn't support the extend method.
// Flip backward selections, so we can set with a single range.
if (!selection.extend && start > end) {
var temp = end;
end = start;
start = temp;
}
var startMarker = getNodeForCharacterOffset(node, start);
var endMarker = getNodeForCharacterOffset(node, end);
if (startMarker && endMarker) {
var range = document.createRange();
range.setStart(startMarker.node, startMarker.offset);
selection.removeAllRanges();
if (start > end) {
selection.addRange(range);
selection.extend(endMarker.node, endMarker.offset);
} else {
range.setEnd(endMarker.node, endMarker.offset);
selection.addRange(range);
}
}
}
|
In modern non-IE browsers, we can support both forward and backward
selections.
Note: IE10+ supports the Selection object, but it does not support
the `extend` method, which means that even in modern IE, it's not possible
to programmatically create a backward selection. Thus, for all IE
versions, we use the old IE API to create our selections.
@param {DOMElement|DOMTextNode} node
@param {object} offsets
|
setModernOffsets
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
function getLeafNode(node) {
while (node && node.firstChild) {
node = node.firstChild;
}
return node;
}
|
Given any node return the first leaf node without children.
@param {DOMElement|DOMTextNode} node
@return {DOMElement|DOMTextNode}
|
getLeafNode
|
javascript
|
stitchfix/pyxley
|
tests/app/static/bundle.js
|
https://github.com/stitchfix/pyxley/blob/master/tests/app/static/bundle.js
|
MIT
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.