| /** |
| * React (with addons) v0.14.1 |
| */ |
| (function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.React = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactWithAddons |
| */ |
| |
| /** |
| * This module exists purely in the open source project, and is meant as a way |
| * to create a separate standalone build of React. This build has "addons", or |
| * functionality we've built and think might be useful but doesn't have a good |
| * place to live inside React core. |
| */ |
| |
| 'use strict'; |
| |
| var LinkedStateMixin = _dereq_(22); |
| var React = _dereq_(26); |
| var ReactComponentWithPureRenderMixin = _dereq_(37); |
| var ReactCSSTransitionGroup = _dereq_(29); |
| var ReactFragment = _dereq_(64); |
| var ReactTransitionGroup = _dereq_(94); |
| var ReactUpdates = _dereq_(96); |
| |
| var cloneWithProps = _dereq_(118); |
| var shallowCompare = _dereq_(140); |
| var update = _dereq_(143); |
| var warning = _dereq_(173); |
| |
| var warnedAboutBatchedUpdates = false; |
| |
| React.addons = { |
| CSSTransitionGroup: ReactCSSTransitionGroup, |
| LinkedStateMixin: LinkedStateMixin, |
| PureRenderMixin: ReactComponentWithPureRenderMixin, |
| TransitionGroup: ReactTransitionGroup, |
| |
| batchedUpdates: function () { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(warnedAboutBatchedUpdates, 'React.addons.batchedUpdates is deprecated. Use ' + 'ReactDOM.unstable_batchedUpdates instead.') : undefined; |
| warnedAboutBatchedUpdates = true; |
| } |
| return ReactUpdates.batchedUpdates.apply(this, arguments); |
| }, |
| cloneWithProps: cloneWithProps, |
| createFragment: ReactFragment.create, |
| shallowCompare: shallowCompare, |
| update: update |
| }; |
| |
| if ("development" !== 'production') { |
| React.addons.Perf = _dereq_(55); |
| React.addons.TestUtils = _dereq_(91); |
| } |
| |
| module.exports = React; |
| },{"118":118,"140":140,"143":143,"173":173,"22":22,"26":26,"29":29,"37":37,"55":55,"64":64,"91":91,"94":94,"96":96}],2:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule AutoFocusUtils |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactMount = _dereq_(72); |
| |
| var findDOMNode = _dereq_(122); |
| var focusNode = _dereq_(155); |
| |
| var Mixin = { |
| componentDidMount: function () { |
| if (this.props.autoFocus) { |
| focusNode(findDOMNode(this)); |
| } |
| } |
| }; |
| |
| var AutoFocusUtils = { |
| Mixin: Mixin, |
| |
| focusDOMComponent: function () { |
| focusNode(ReactMount.getNode(this._rootNodeID)); |
| } |
| }; |
| |
| module.exports = AutoFocusUtils; |
| },{"122":122,"155":155,"72":72}],3:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015 Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule BeforeInputEventPlugin |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPropagators = _dereq_(19); |
| var ExecutionEnvironment = _dereq_(147); |
| var FallbackCompositionState = _dereq_(20); |
| var SyntheticCompositionEvent = _dereq_(103); |
| var SyntheticInputEvent = _dereq_(107); |
| |
| var keyOf = _dereq_(166); |
| |
| var END_KEYCODES = [9, 13, 27, 32]; // Tab, Return, Esc, Space |
| var START_KEYCODE = 229; |
| |
| var canUseCompositionEvent = ExecutionEnvironment.canUseDOM && 'CompositionEvent' in window; |
| |
| var documentMode = null; |
| if (ExecutionEnvironment.canUseDOM && 'documentMode' in document) { |
| documentMode = document.documentMode; |
| } |
| |
| // Webkit offers a very useful `textInput` event that can be used to |
| // directly represent `beforeInput`. The IE `textinput` event is not as |
| // useful, so we don't use it. |
| var canUseTextInputEvent = ExecutionEnvironment.canUseDOM && 'TextEvent' in window && !documentMode && !isPresto(); |
| |
| // In IE9+, we have access to composition events, but the data supplied |
| // by the native compositionend event may be incorrect. Japanese ideographic |
| // spaces, for instance (\u3000) are not recorded correctly. |
| var useFallbackCompositionData = ExecutionEnvironment.canUseDOM && (!canUseCompositionEvent || documentMode && documentMode > 8 && documentMode <= 11); |
| |
| /** |
| * Opera <= 12 includes TextEvent in window, but does not fire |
| * text input events. Rely on keypress instead. |
| */ |
| function isPresto() { |
| var opera = window.opera; |
| return typeof opera === 'object' && typeof opera.version === 'function' && parseInt(opera.version(), 10) <= 12; |
| } |
| |
| var SPACEBAR_CODE = 32; |
| var SPACEBAR_CHAR = String.fromCharCode(SPACEBAR_CODE); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| // Events and their corresponding property names. |
| var eventTypes = { |
| beforeInput: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onBeforeInput: null }), |
| captured: keyOf({ onBeforeInputCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topCompositionEnd, topLevelTypes.topKeyPress, topLevelTypes.topTextInput, topLevelTypes.topPaste] |
| }, |
| compositionEnd: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCompositionEnd: null }), |
| captured: keyOf({ onCompositionEndCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionEnd, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown] |
| }, |
| compositionStart: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCompositionStart: null }), |
| captured: keyOf({ onCompositionStartCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionStart, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown] |
| }, |
| compositionUpdate: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCompositionUpdate: null }), |
| captured: keyOf({ onCompositionUpdateCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topBlur, topLevelTypes.topCompositionUpdate, topLevelTypes.topKeyDown, topLevelTypes.topKeyPress, topLevelTypes.topKeyUp, topLevelTypes.topMouseDown] |
| } |
| }; |
| |
| // Track whether we've ever handled a keypress on the space key. |
| var hasSpaceKeypress = false; |
| |
| /** |
| * Return whether a native keypress event is assumed to be a command. |
| * This is required because Firefox fires `keypress` events for key commands |
| * (cut, copy, select-all, etc.) even though no character is inserted. |
| */ |
| function isKeypressCommand(nativeEvent) { |
| return (nativeEvent.ctrlKey || nativeEvent.altKey || nativeEvent.metaKey) && |
| // ctrlKey && altKey is equivalent to AltGr, and is not a command. |
| !(nativeEvent.ctrlKey && nativeEvent.altKey); |
| } |
| |
| /** |
| * Translate native top level events into event types. |
| * |
| * @param {string} topLevelType |
| * @return {object} |
| */ |
| function getCompositionEventType(topLevelType) { |
| switch (topLevelType) { |
| case topLevelTypes.topCompositionStart: |
| return eventTypes.compositionStart; |
| case topLevelTypes.topCompositionEnd: |
| return eventTypes.compositionEnd; |
| case topLevelTypes.topCompositionUpdate: |
| return eventTypes.compositionUpdate; |
| } |
| } |
| |
| /** |
| * Does our fallback best-guess model think this event signifies that |
| * composition has begun? |
| * |
| * @param {string} topLevelType |
| * @param {object} nativeEvent |
| * @return {boolean} |
| */ |
| function isFallbackCompositionStart(topLevelType, nativeEvent) { |
| return topLevelType === topLevelTypes.topKeyDown && nativeEvent.keyCode === START_KEYCODE; |
| } |
| |
| /** |
| * Does our fallback mode think that this event is the end of composition? |
| * |
| * @param {string} topLevelType |
| * @param {object} nativeEvent |
| * @return {boolean} |
| */ |
| function isFallbackCompositionEnd(topLevelType, nativeEvent) { |
| switch (topLevelType) { |
| case topLevelTypes.topKeyUp: |
| // Command keys insert or clear IME input. |
| return END_KEYCODES.indexOf(nativeEvent.keyCode) !== -1; |
| case topLevelTypes.topKeyDown: |
| // Expect IME keyCode on each keydown. If we get any other |
| // code we must have exited earlier. |
| return nativeEvent.keyCode !== START_KEYCODE; |
| case topLevelTypes.topKeyPress: |
| case topLevelTypes.topMouseDown: |
| case topLevelTypes.topBlur: |
| // Events are not possible without cancelling IME. |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| /** |
| * Google Input Tools provides composition data via a CustomEvent, |
| * with the `data` property populated in the `detail` object. If this |
| * is available on the event object, use it. If not, this is a plain |
| * composition event and we have nothing special to extract. |
| * |
| * @param {object} nativeEvent |
| * @return {?string} |
| */ |
| function getDataFromCustomEvent(nativeEvent) { |
| var detail = nativeEvent.detail; |
| if (typeof detail === 'object' && 'data' in detail) { |
| return detail.data; |
| } |
| return null; |
| } |
| |
| // Track the current IME composition fallback object, if any. |
| var currentComposition = null; |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {?object} A SyntheticCompositionEvent. |
| */ |
| function extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| var eventType; |
| var fallbackData; |
| |
| if (canUseCompositionEvent) { |
| eventType = getCompositionEventType(topLevelType); |
| } else if (!currentComposition) { |
| if (isFallbackCompositionStart(topLevelType, nativeEvent)) { |
| eventType = eventTypes.compositionStart; |
| } |
| } else if (isFallbackCompositionEnd(topLevelType, nativeEvent)) { |
| eventType = eventTypes.compositionEnd; |
| } |
| |
| if (!eventType) { |
| return null; |
| } |
| |
| if (useFallbackCompositionData) { |
| // The current composition is stored statically and must not be |
| // overwritten while composition continues. |
| if (!currentComposition && eventType === eventTypes.compositionStart) { |
| currentComposition = FallbackCompositionState.getPooled(topLevelTarget); |
| } else if (eventType === eventTypes.compositionEnd) { |
| if (currentComposition) { |
| fallbackData = currentComposition.getData(); |
| } |
| } |
| } |
| |
| var event = SyntheticCompositionEvent.getPooled(eventType, topLevelTargetID, nativeEvent, nativeEventTarget); |
| |
| if (fallbackData) { |
| // Inject data generated from fallback path into the synthetic event. |
| // This matches the property of native CompositionEventInterface. |
| event.data = fallbackData; |
| } else { |
| var customData = getDataFromCustomEvent(nativeEvent); |
| if (customData !== null) { |
| event.data = customData; |
| } |
| } |
| |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| return event; |
| } |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {?string} The string corresponding to this `beforeInput` event. |
| */ |
| function getNativeBeforeInputChars(topLevelType, nativeEvent) { |
| switch (topLevelType) { |
| case topLevelTypes.topCompositionEnd: |
| return getDataFromCustomEvent(nativeEvent); |
| case topLevelTypes.topKeyPress: |
| /** |
| * If native `textInput` events are available, our goal is to make |
| * use of them. However, there is a special case: the spacebar key. |
| * In Webkit, preventing default on a spacebar `textInput` event |
| * cancels character insertion, but it *also* causes the browser |
| * to fall back to its default spacebar behavior of scrolling the |
| * page. |
| * |
| * Tracking at: |
| * https://code.google.com/p/chromium/issues/detail?id=355103 |
| * |
| * To avoid this issue, use the keypress event as if no `textInput` |
| * event is available. |
| */ |
| var which = nativeEvent.which; |
| if (which !== SPACEBAR_CODE) { |
| return null; |
| } |
| |
| hasSpaceKeypress = true; |
| return SPACEBAR_CHAR; |
| |
| case topLevelTypes.topTextInput: |
| // Record the characters to be added to the DOM. |
| var chars = nativeEvent.data; |
| |
| // If it's a spacebar character, assume that we have already handled |
| // it at the keypress level and bail immediately. Android Chrome |
| // doesn't give us keycodes, so we need to blacklist it. |
| if (chars === SPACEBAR_CHAR && hasSpaceKeypress) { |
| return null; |
| } |
| |
| return chars; |
| |
| default: |
| // For other native event types, do nothing. |
| 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. |
| */ |
| 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 (currentComposition) { |
| if (topLevelType === topLevelTypes.topCompositionEnd || isFallbackCompositionEnd(topLevelType, nativeEvent)) { |
| var chars = currentComposition.getData(); |
| FallbackCompositionState.release(currentComposition); |
| currentComposition = null; |
| return chars; |
| } |
| return null; |
| } |
| |
| switch (topLevelType) { |
| case topLevelTypes.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 topLevelTypes.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 topLevelTypes.topCompositionEnd: |
| return useFallbackCompositionData ? null : nativeEvent.data; |
| default: |
| return null; |
| } |
| } |
| |
| /** |
| * Extract a SyntheticInputEvent for `beforeInput`, based on either native |
| * `textInput` or fallback behavior. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {?object} A SyntheticInputEvent. |
| */ |
| function extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, 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, topLevelTargetID, nativeEvent, nativeEventTarget); |
| |
| event.data = chars; |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| return event; |
| } |
| |
| /** |
| * Create an `onBeforeInput` event to match |
| * http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105/#events-inputevents. |
| * |
| * This event plugin is based on the native `textInput` event |
| * available in Chrome, Safari, Opera, and IE. This event fires after |
| * `onKeyPress` and `onCompositionEnd`, but before `onInput`. |
| * |
| * `beforeInput` is spec'd but not implemented in any browsers, and |
| * the `input` event does not provide any useful information about what has |
| * actually been added, contrary to the spec. Thus, `textInput` is the best |
| * available event to identify the characters that have actually been inserted |
| * into the target node. |
| * |
| * This plugin is also responsible for emitting `composition` events, thus |
| * allowing us to share composition fallback code for both `beforeInput` and |
| * `composition` event types. |
| */ |
| var BeforeInputEventPlugin = { |
| |
| eventTypes: eventTypes, |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @see {EventPluginHub.extractEvents} |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| return [extractCompositionEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget), extractBeforeInputEvent(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget)]; |
| } |
| }; |
| |
| module.exports = BeforeInputEventPlugin; |
| },{"103":103,"107":107,"147":147,"15":15,"166":166,"19":19,"20":20}],4:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule CSSProperty |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * CSS properties which accept numbers but are not in units of "px". |
| */ |
| var isUnitlessNumber = { |
| animationIterationCount: true, |
| boxFlex: true, |
| boxFlexGroup: true, |
| boxOrdinalGroup: true, |
| columnCount: true, |
| flex: true, |
| flexGrow: true, |
| flexPositive: true, |
| flexShrink: true, |
| flexNegative: true, |
| flexOrder: true, |
| fontWeight: true, |
| lineClamp: true, |
| lineHeight: true, |
| opacity: true, |
| order: true, |
| orphans: true, |
| tabSize: true, |
| widows: true, |
| zIndex: true, |
| zoom: true, |
| |
| // SVG-related properties |
| fillOpacity: true, |
| stopOpacity: true, |
| strokeDashoffset: true, |
| strokeOpacity: true, |
| strokeWidth: true |
| }; |
| |
| /** |
| * @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 |
| */ |
| function prefixKey(prefix, key) { |
| return prefix + key.charAt(0).toUpperCase() + key.substring(1); |
| } |
| |
| /** |
| * Support style names that may come passed in prefixed by adding permutations |
| * of vendor prefixes. |
| */ |
| var prefixes = ['Webkit', 'ms', 'Moz', 'O']; |
| |
| // Using Object.keys here, or else the vanilla for-in loop makes IE8 go into an |
| // infinite loop, because it iterates over the newly added props too. |
| Object.keys(isUnitlessNumber).forEach(function (prop) { |
| prefixes.forEach(function (prefix) { |
| isUnitlessNumber[prefixKey(prefix, prop)] = isUnitlessNumber[prop]; |
| }); |
| }); |
| |
| /** |
| * Most style properties can be unset by doing .style[prop] = '' but IE8 |
| * doesn't like doing that with shorthand properties so for the properties that |
| * IE8 breaks on, which are listed here, we instead unset each of the |
| * individual properties. See http://bugs.jquery.com/ticket/12385. |
| * The 4-value 'clock' properties like margin, padding, border-width seem to |
| * behave without any problems. Curiously, list-style works too without any |
| * special prodding. |
| */ |
| var shorthandPropertyExpansions = { |
| background: { |
| backgroundAttachment: true, |
| backgroundColor: true, |
| backgroundImage: true, |
| backgroundPositionX: true, |
| backgroundPositionY: true, |
| backgroundRepeat: true |
| }, |
| backgroundPosition: { |
| backgroundPositionX: true, |
| backgroundPositionY: true |
| }, |
| border: { |
| borderWidth: true, |
| borderStyle: true, |
| borderColor: true |
| }, |
| borderBottom: { |
| borderBottomWidth: true, |
| borderBottomStyle: true, |
| borderBottomColor: true |
| }, |
| borderLeft: { |
| borderLeftWidth: true, |
| borderLeftStyle: true, |
| borderLeftColor: true |
| }, |
| borderRight: { |
| borderRightWidth: true, |
| borderRightStyle: true, |
| borderRightColor: true |
| }, |
| borderTop: { |
| borderTopWidth: true, |
| borderTopStyle: true, |
| borderTopColor: true |
| }, |
| font: { |
| fontStyle: true, |
| fontVariant: true, |
| fontWeight: true, |
| fontSize: true, |
| lineHeight: true, |
| fontFamily: true |
| }, |
| outline: { |
| outlineWidth: true, |
| outlineStyle: true, |
| outlineColor: true |
| } |
| }; |
| |
| var CSSProperty = { |
| isUnitlessNumber: isUnitlessNumber, |
| shorthandPropertyExpansions: shorthandPropertyExpansions |
| }; |
| |
| module.exports = CSSProperty; |
| },{}],5:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule CSSPropertyOperations |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var CSSProperty = _dereq_(4); |
| var ExecutionEnvironment = _dereq_(147); |
| var ReactPerf = _dereq_(78); |
| |
| var camelizeStyleName = _dereq_(149); |
| var dangerousStyleValue = _dereq_(119); |
| var hyphenateStyleName = _dereq_(160); |
| var memoizeStringOnly = _dereq_(168); |
| var warning = _dereq_(173); |
| |
| var processStyleName = memoizeStringOnly(function (styleName) { |
| return hyphenateStyleName(styleName); |
| }); |
| |
| var hasShorthandPropertyBug = false; |
| var styleFloatAccessor = 'cssFloat'; |
| if (ExecutionEnvironment.canUseDOM) { |
| var tempStyle = document.createElement('div').style; |
| try { |
| // IE8 throws "Invalid argument." if resetting shorthand style properties. |
| tempStyle.font = ''; |
| } catch (e) { |
| hasShorthandPropertyBug = true; |
| } |
| // IE8 only supports accessing cssFloat (standard) as styleFloat |
| if (document.documentElement.style.cssFloat === undefined) { |
| styleFloatAccessor = 'styleFloat'; |
| } |
| } |
| |
| if ("development" !== 'production') { |
| // 'msTransform' is correct, but the other prefixes should be capitalized |
| var badVendoredStyleNamePattern = /^(?:webkit|moz|o)[A-Z]/; |
| |
| // style values shouldn't contain a semicolon |
| var badStyleValueWithSemicolonPattern = /;\s*$/; |
| |
| var warnedStyleNames = {}; |
| var warnedStyleValues = {}; |
| |
| var warnHyphenatedStyleName = function (name) { |
| if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) { |
| return; |
| } |
| |
| warnedStyleNames[name] = true; |
| "development" !== 'production' ? warning(false, 'Unsupported style property %s. Did you mean %s?', name, camelizeStyleName(name)) : undefined; |
| }; |
| |
| var warnBadVendoredStyleName = function (name) { |
| if (warnedStyleNames.hasOwnProperty(name) && warnedStyleNames[name]) { |
| return; |
| } |
| |
| warnedStyleNames[name] = true; |
| "development" !== 'production' ? warning(false, 'Unsupported vendor-prefixed style property %s. Did you mean %s?', name, name.charAt(0).toUpperCase() + name.slice(1)) : undefined; |
| }; |
| |
| var warnStyleValueWithSemicolon = function (name, value) { |
| if (warnedStyleValues.hasOwnProperty(value) && warnedStyleValues[value]) { |
| return; |
| } |
| |
| warnedStyleValues[value] = true; |
| "development" !== 'production' ? warning(false, 'Style property values shouldn\'t contain a semicolon. ' + 'Try "%s: %s" instead.', name, value.replace(badStyleValueWithSemicolonPattern, '')) : undefined; |
| }; |
| |
| /** |
| * @param {string} name |
| * @param {*} value |
| */ |
| var warnValidStyle = function (name, value) { |
| if (name.indexOf('-') > -1) { |
| warnHyphenatedStyleName(name); |
| } else if (badVendoredStyleNamePattern.test(name)) { |
| warnBadVendoredStyleName(name); |
| } else if (badStyleValueWithSemicolonPattern.test(value)) { |
| warnStyleValueWithSemicolon(name, value); |
| } |
| }; |
| } |
| |
| /** |
| * Operations for dealing with CSS properties. |
| */ |
| var CSSPropertyOperations = { |
| |
| /** |
| * Serializes a mapping of style properties for use as inline styles: |
| * |
| * > createMarkupForStyles({width: '200px', height: 0}) |
| * "width:200px;height:0;" |
| * |
| * Undefined values are ignored so that declarative programming is easier. |
| * The result should be HTML-escaped before insertion into the DOM. |
| * |
| * @param {object} styles |
| * @return {?string} |
| */ |
| createMarkupForStyles: function (styles) { |
| var serialized = ''; |
| for (var styleName in styles) { |
| if (!styles.hasOwnProperty(styleName)) { |
| continue; |
| } |
| var styleValue = styles[styleName]; |
| if ("development" !== 'production') { |
| warnValidStyle(styleName, styleValue); |
| } |
| if (styleValue != null) { |
| serialized += processStyleName(styleName) + ':'; |
| serialized += dangerousStyleValue(styleName, styleValue) + ';'; |
| } |
| } |
| return serialized || null; |
| }, |
| |
| /** |
| * Sets the value for multiple styles on a node. If a value is specified as |
| * '' (empty string), the corresponding style property will be unset. |
| * |
| * @param {DOMElement} node |
| * @param {object} styles |
| */ |
| setValueForStyles: function (node, styles) { |
| var style = node.style; |
| for (var styleName in styles) { |
| if (!styles.hasOwnProperty(styleName)) { |
| continue; |
| } |
| if ("development" !== 'production') { |
| warnValidStyle(styleName, styles[styleName]); |
| } |
| var styleValue = dangerousStyleValue(styleName, styles[styleName]); |
| if (styleName === 'float') { |
| styleName = styleFloatAccessor; |
| } |
| if (styleValue) { |
| style[styleName] = styleValue; |
| } else { |
| var expansion = hasShorthandPropertyBug && CSSProperty.shorthandPropertyExpansions[styleName]; |
| if (expansion) { |
| // Shorthand property that IE8 won't like unsetting, so unset each |
| // component to placate it |
| for (var individualStyleName in expansion) { |
| style[individualStyleName] = ''; |
| } |
| } else { |
| style[styleName] = ''; |
| } |
| } |
| } |
| } |
| |
| }; |
| |
| ReactPerf.measureMethods(CSSPropertyOperations, 'CSSPropertyOperations', { |
| setValueForStyles: 'setValueForStyles' |
| }); |
| |
| module.exports = CSSPropertyOperations; |
| },{"119":119,"147":147,"149":149,"160":160,"168":168,"173":173,"4":4,"78":78}],6:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule CallbackQueue |
| */ |
| |
| 'use strict'; |
| |
| var PooledClass = _dereq_(25); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| |
| /** |
| * 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 |
| */ |
| function CallbackQueue() { |
| this._callbacks = null; |
| this._contexts = null; |
| } |
| |
| assign(CallbackQueue.prototype, { |
| |
| /** |
| * Enqueues a callback to be invoked when `notifyAll` is invoked. |
| * |
| * @param {function} callback Invoked when `notifyAll` is invoked. |
| * @param {?object} context Context to call `callback` with. |
| * @internal |
| */ |
| enqueue: function (callback, context) { |
| this._callbacks = this._callbacks || []; |
| this._contexts = this._contexts || []; |
| this._callbacks.push(callback); |
| this._contexts.push(context); |
| }, |
| |
| /** |
| * Invokes all enqueued callbacks and clears the queue. This is invoked after |
| * the DOM representation of a component has been created or updated. |
| * |
| * @internal |
| */ |
| notifyAll: function () { |
| var callbacks = this._callbacks; |
| var contexts = this._contexts; |
| if (callbacks) { |
| !(callbacks.length === contexts.length) ? "development" !== 'production' ? invariant(false, 'Mismatched list of contexts in callback queue') : invariant(false) : undefined; |
| this._callbacks = null; |
| this._contexts = null; |
| for (var i = 0; i < callbacks.length; i++) { |
| callbacks[i].call(contexts[i]); |
| } |
| callbacks.length = 0; |
| contexts.length = 0; |
| } |
| }, |
| |
| /** |
| * Resets the internal queue. |
| * |
| * @internal |
| */ |
| reset: function () { |
| this._callbacks = null; |
| this._contexts = null; |
| }, |
| |
| /** |
| * `PooledClass` looks for this. |
| */ |
| destructor: function () { |
| this.reset(); |
| } |
| |
| }); |
| |
| PooledClass.addPoolingTo(CallbackQueue); |
| |
| module.exports = CallbackQueue; |
| },{"161":161,"24":24,"25":25}],7:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ChangeEventPlugin |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPluginHub = _dereq_(16); |
| var EventPropagators = _dereq_(19); |
| var ExecutionEnvironment = _dereq_(147); |
| var ReactUpdates = _dereq_(96); |
| var SyntheticEvent = _dereq_(105); |
| |
| var getEventTarget = _dereq_(128); |
| var isEventSupported = _dereq_(133); |
| var isTextInputElement = _dereq_(134); |
| var keyOf = _dereq_(166); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| var eventTypes = { |
| change: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onChange: null }), |
| captured: keyOf({ onChangeCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topBlur, topLevelTypes.topChange, topLevelTypes.topClick, topLevelTypes.topFocus, topLevelTypes.topInput, topLevelTypes.topKeyDown, topLevelTypes.topKeyUp, topLevelTypes.topSelectionChange] |
| } |
| }; |
| |
| /** |
| * For IE shims |
| */ |
| var activeElement = null; |
| var activeElementID = null; |
| var activeElementValue = null; |
| var activeElementValueProp = null; |
| |
| /** |
| * SECTION: handle `change` event |
| */ |
| function shouldUseChangeEvent(elem) { |
| var nodeName = elem.nodeName && elem.nodeName.toLowerCase(); |
| return nodeName === 'select' || nodeName === 'input' && elem.type === 'file'; |
| } |
| |
| var doesChangeEventBubble = false; |
| if (ExecutionEnvironment.canUseDOM) { |
| // See `handleChange` comment below |
| doesChangeEventBubble = isEventSupported('change') && (!('documentMode' in document) || document.documentMode > 8); |
| } |
| |
| function manualDispatchChangeEvent(nativeEvent) { |
| var event = SyntheticEvent.getPooled(eventTypes.change, activeElementID, nativeEvent, getEventTarget(nativeEvent)); |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| |
| // If change and propertychange bubbled, we'd just bind to it like all the |
| // other events and have it go through ReactBrowserEventEmitter. Since it |
| // doesn't, we manually listen for the events and so we have to enqueue and |
| // process the abstract event manually. |
| // |
| // Batching is necessary here in order to ensure that all event handlers run |
| // before the next rerender (including event handlers attached to ancestor |
| // elements instead of directly on the input). Without this, controlled |
| // components don't work properly in conjunction with event bubbling because |
| // the component is rerendered and the value reverted before all the event |
| // handlers can run. See https://github.com/facebook/react/issues/708. |
| ReactUpdates.batchedUpdates(runEventInBatch, event); |
| } |
| |
| function runEventInBatch(event) { |
| EventPluginHub.enqueueEvents(event); |
| EventPluginHub.processEventQueue(false); |
| } |
| |
| function startWatchingForChangeEventIE8(target, targetID) { |
| activeElement = target; |
| activeElementID = targetID; |
| activeElement.attachEvent('onchange', manualDispatchChangeEvent); |
| } |
| |
| function stopWatchingForChangeEventIE8() { |
| if (!activeElement) { |
| return; |
| } |
| activeElement.detachEvent('onchange', manualDispatchChangeEvent); |
| activeElement = null; |
| activeElementID = null; |
| } |
| |
| function getTargetIDForChangeEvent(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.topChange) { |
| return topLevelTargetID; |
| } |
| } |
| function handleEventsForChangeEventIE8(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.topFocus) { |
| // stopWatching() should be a noop here but we call it just in case we |
| // missed a blur event somehow. |
| stopWatchingForChangeEventIE8(); |
| startWatchingForChangeEventIE8(topLevelTarget, topLevelTargetID); |
| } else if (topLevelType === topLevelTypes.topBlur) { |
| stopWatchingForChangeEventIE8(); |
| } |
| } |
| |
| /** |
| * SECTION: handle `input` event |
| */ |
| var isInputEventSupported = false; |
| if (ExecutionEnvironment.canUseDOM) { |
| // IE9 claims to support the input event but fails to trigger it when |
| // deleting text, so we ignore its input events |
| isInputEventSupported = isEventSupported('input') && (!('documentMode' in document) || document.documentMode > 9); |
| } |
| |
| /** |
| * (For old IE.) Replacement getter/setter for the `value` property that gets |
| * set on the active element. |
| */ |
| var newValueProp = { |
| get: function () { |
| return activeElementValueProp.get.call(this); |
| }, |
| set: function (val) { |
| // Cast to a string so we can do equality checks. |
| activeElementValue = '' + val; |
| activeElementValueProp.set.call(this, val); |
| } |
| }; |
| |
| /** |
| * (For old IE.) 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. |
| */ |
| function startWatchingForValueChange(target, targetID) { |
| activeElement = target; |
| activeElementID = targetID; |
| 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); |
| activeElement.attachEvent('onpropertychange', handlePropertyChange); |
| } |
| |
| /** |
| * (For old IE.) Removes the event listeners from the currently-tracked element, |
| * if any exists. |
| */ |
| function stopWatchingForValueChange() { |
| if (!activeElement) { |
| return; |
| } |
| |
| // delete restores the original property definition |
| delete activeElement.value; |
| activeElement.detachEvent('onpropertychange', handlePropertyChange); |
| |
| activeElement = null; |
| activeElementID = null; |
| activeElementValue = null; |
| activeElementValueProp = null; |
| } |
| |
| /** |
| * (For old IE.) Handles a propertychange event, sending a `change` event if |
| * the value of the active element has changed. |
| */ |
| function handlePropertyChange(nativeEvent) { |
| if (nativeEvent.propertyName !== 'value') { |
| return; |
| } |
| var value = nativeEvent.srcElement.value; |
| if (value === activeElementValue) { |
| return; |
| } |
| activeElementValue = value; |
| |
| manualDispatchChangeEvent(nativeEvent); |
| } |
| |
| /** |
| * If a `change` event should be fired, returns the target's ID. |
| */ |
| function getTargetIDForInputEvent(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.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 topLevelTargetID; |
| } |
| } |
| |
| // For IE8 and IE9. |
| function handleEventsForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.topFocus) { |
| // In IE8, we can capture almost all .value changes by adding a |
| // propertychange handler and looking for events with propertyName |
| // equal to 'value' |
| // In IE9, propertychange fires for most input events but is buggy and |
| // doesn't fire when text is deleted, but conveniently, selectionchange |
| // appears to fire in all of the remaining cases so we catch those and |
| // forward the event if the value has changed |
| // In either case, we don't want to call the event handler if the value |
| // is changed from JS so we redefine a setter for `.value` that updates |
| // our activeElementValue variable, allowing us to ignore those changes |
| // |
| // stopWatching() should be a noop here but we call it just in case we |
| // missed a blur event somehow. |
| stopWatchingForValueChange(); |
| startWatchingForValueChange(topLevelTarget, topLevelTargetID); |
| } else if (topLevelType === topLevelTypes.topBlur) { |
| stopWatchingForValueChange(); |
| } |
| } |
| |
| // For IE8 and IE9. |
| function getTargetIDForInputEventIE(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.topSelectionChange || topLevelType === topLevelTypes.topKeyUp || topLevelType === topLevelTypes.topKeyDown) { |
| // On the selectionchange event, the target is just document which isn't |
| // helpful for us so just check activeElement instead. |
| // |
| // 99% of the time, keydown and keyup aren't necessary. IE8 fails to fire |
| // propertychange on the first input event after setting `value` from a |
| // script and fires only keydown, keypress, keyup. Catching keyup usually |
| // gets it and catching keydown lets us fire an event for the first |
| // keystroke if user does a key repeat (it'll be a little delayed: right |
| // before the second keystroke). Other input methods (e.g., paste) seem to |
| // fire selectionchange normally. |
| if (activeElement && activeElement.value !== activeElementValue) { |
| activeElementValue = activeElement.value; |
| return activeElementID; |
| } |
| } |
| } |
| |
| /** |
| * SECTION: handle `click` event |
| */ |
| function shouldUseClickEvent(elem) { |
| // Use the `click` event to detect changes to checkbox and radio inputs. |
| // This approach works across all browsers, whereas `change` does not fire |
| // until `blur` in IE8. |
| return elem.nodeName && elem.nodeName.toLowerCase() === 'input' && (elem.type === 'checkbox' || elem.type === 'radio'); |
| } |
| |
| function getTargetIDForClickEvent(topLevelType, topLevelTarget, topLevelTargetID) { |
| if (topLevelType === topLevelTypes.topClick) { |
| return topLevelTargetID; |
| } |
| } |
| |
| /** |
| * This plugin creates an `onChange` event that normalizes change events |
| * across form elements. This event fires at a time when it's possible to |
| * change the element's value without seeing a flicker. |
| * |
| * Supported elements are: |
| * - input (see `isTextInputElement`) |
| * - textarea |
| * - select |
| */ |
| var ChangeEventPlugin = { |
| |
| eventTypes: eventTypes, |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @see {EventPluginHub.extractEvents} |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| |
| var getTargetIDFunc, handleEventFunc; |
| if (shouldUseChangeEvent(topLevelTarget)) { |
| if (doesChangeEventBubble) { |
| getTargetIDFunc = getTargetIDForChangeEvent; |
| } else { |
| handleEventFunc = handleEventsForChangeEventIE8; |
| } |
| } else if (isTextInputElement(topLevelTarget)) { |
| if (isInputEventSupported) { |
| getTargetIDFunc = getTargetIDForInputEvent; |
| } else { |
| getTargetIDFunc = getTargetIDForInputEventIE; |
| handleEventFunc = handleEventsForInputEventIE; |
| } |
| } else if (shouldUseClickEvent(topLevelTarget)) { |
| getTargetIDFunc = getTargetIDForClickEvent; |
| } |
| |
| if (getTargetIDFunc) { |
| var targetID = getTargetIDFunc(topLevelType, topLevelTarget, topLevelTargetID); |
| if (targetID) { |
| var event = SyntheticEvent.getPooled(eventTypes.change, targetID, nativeEvent, nativeEventTarget); |
| event.type = 'change'; |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| return event; |
| } |
| } |
| |
| if (handleEventFunc) { |
| handleEventFunc(topLevelType, topLevelTarget, topLevelTargetID); |
| } |
| } |
| |
| }; |
| |
| module.exports = ChangeEventPlugin; |
| },{"105":105,"128":128,"133":133,"134":134,"147":147,"15":15,"16":16,"166":166,"19":19,"96":96}],8:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ClientReactRootIndex |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var nextReactRootIndex = 0; |
| |
| var ClientReactRootIndex = { |
| createReactRootIndex: function () { |
| return nextReactRootIndex++; |
| } |
| }; |
| |
| module.exports = ClientReactRootIndex; |
| },{}],9:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule DOMChildrenOperations |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var Danger = _dereq_(12); |
| var ReactMultiChildUpdateTypes = _dereq_(74); |
| var ReactPerf = _dereq_(78); |
| |
| var setInnerHTML = _dereq_(138); |
| var setTextContent = _dereq_(139); |
| var invariant = _dereq_(161); |
| |
| /** |
| * 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 |
| */ |
| function insertChildAt(parentNode, childNode, index) { |
| // By exploiting arrays returning `undefined` for an undefined index, we can |
| // rely exclusively on `insertBefore(node, null)` instead of also using |
| // `appendChild(node)`. However, using `undefined` is not allowed by all |
| // browsers so we must replace it with `null`. |
| |
| // fix render order error in safari |
| // IE8 will throw error when index out of list size. |
| var beforeChild = index >= parentNode.childNodes.length ? null : parentNode.childNodes.item(index); |
| |
| parentNode.insertBefore(childNode, beforeChild); |
| } |
| |
| /** |
| * Operations for updating with DOM children. |
| */ |
| var DOMChildrenOperations = { |
| |
| dangerouslyReplaceNodeWithMarkup: Danger.dangerouslyReplaceNodeWithMarkup, |
| |
| updateTextContent: setTextContent, |
| |
| /** |
| * Updates a component's children by processing a series of updates. The |
| * update configurations are each expected to have a `parentNode` property. |
| * |
| * @param {array<object>} updates List of update configurations. |
| * @param {array<string>} markupList List of markup strings. |
| * @internal |
| */ |
| processUpdates: function (updates, markupList) { |
| var update; |
| // Mapping from parent IDs to initial child orderings. |
| var initialChildren = null; |
| // List of children that will be moved or removed. |
| var updatedChildren = null; |
| |
| for (var i = 0; i < updates.length; i++) { |
| update = updates[i]; |
| if (update.type === ReactMultiChildUpdateTypes.MOVE_EXISTING || update.type === ReactMultiChildUpdateTypes.REMOVE_NODE) { |
| var updatedIndex = update.fromIndex; |
| var updatedChild = update.parentNode.childNodes[updatedIndex]; |
| var parentID = update.parentID; |
| |
| !updatedChild ? "development" !== 'production' ? invariant(false, 'processUpdates(): Unable to find child %s of element. This ' + 'probably means the DOM was unexpectedly mutated (e.g., by the ' + 'browser), usually due to forgetting a <tbody> when using tables, ' + 'nesting tags like <form>, <p>, or <a>, or using non-SVG elements ' + 'in an <svg> parent. Try inspecting the child nodes of the element ' + 'with React ID `%s`.', updatedIndex, parentID) : invariant(false) : undefined; |
| |
| initialChildren = initialChildren || {}; |
| initialChildren[parentID] = initialChildren[parentID] || []; |
| initialChildren[parentID][updatedIndex] = updatedChild; |
| |
| updatedChildren = updatedChildren || []; |
| updatedChildren.push(updatedChild); |
| } |
| } |
| |
| var renderedMarkup; |
| // markupList is either a list of markup or just a list of elements |
| if (markupList.length && typeof markupList[0] === 'string') { |
| renderedMarkup = Danger.dangerouslyRenderMarkup(markupList); |
| } else { |
| renderedMarkup = markupList; |
| } |
| |
| // Remove updated children first so that `toIndex` is consistent. |
| if (updatedChildren) { |
| for (var j = 0; j < updatedChildren.length; j++) { |
| updatedChildren[j].parentNode.removeChild(updatedChildren[j]); |
| } |
| } |
| |
| for (var k = 0; k < updates.length; k++) { |
| update = updates[k]; |
| switch (update.type) { |
| case ReactMultiChildUpdateTypes.INSERT_MARKUP: |
| insertChildAt(update.parentNode, renderedMarkup[update.markupIndex], update.toIndex); |
| break; |
| case ReactMultiChildUpdateTypes.MOVE_EXISTING: |
| insertChildAt(update.parentNode, initialChildren[update.parentID][update.fromIndex], update.toIndex); |
| break; |
| case ReactMultiChildUpdateTypes.SET_MARKUP: |
| setInnerHTML(update.parentNode, update.content); |
| break; |
| case ReactMultiChildUpdateTypes.TEXT_CONTENT: |
| setTextContent(update.parentNode, update.content); |
| break; |
| case ReactMultiChildUpdateTypes.REMOVE_NODE: |
| // Already removed by the for-loop above. |
| break; |
| } |
| } |
| } |
| |
| }; |
| |
| ReactPerf.measureMethods(DOMChildrenOperations, 'DOMChildrenOperations', { |
| updateTextContent: 'updateTextContent' |
| }); |
| |
| module.exports = DOMChildrenOperations; |
| },{"12":12,"138":138,"139":139,"161":161,"74":74,"78":78}],10:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule DOMProperty |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| function checkMask(value, bitmask) { |
| return (value & bitmask) === bitmask; |
| } |
| |
| var DOMPropertyInjection = { |
| /** |
| * Mapping from normalized, camelcased property names to a configuration that |
| * specifies how the associated DOM property should be accessed or rendered. |
| */ |
| MUST_USE_ATTRIBUTE: 0x1, |
| MUST_USE_PROPERTY: 0x2, |
| HAS_SIDE_EFFECTS: 0x4, |
| HAS_BOOLEAN_VALUE: 0x8, |
| HAS_NUMERIC_VALUE: 0x10, |
| HAS_POSITIVE_NUMERIC_VALUE: 0x20 | 0x10, |
| HAS_OVERLOADED_BOOLEAN_VALUE: 0x40, |
| |
| /** |
| * Inject some specialized knowledge about the DOM. This takes a config object |
| * with the following properties: |
| * |
| * isCustomAttribute: function that given an attribute name will return true |
| * if it can be inserted into the DOM verbatim. Useful for data-* or aria-* |
| * attributes where it's impossible to enumerate all of the possible |
| * attribute names, |
| * |
| * Properties: object mapping DOM property name to one of the |
| * DOMPropertyInjection constants or null. If your attribute isn't in here, |
| * it won't get written to the DOM. |
| * |
| * DOMAttributeNames: object mapping React attribute name to the DOM |
| * attribute name. Attribute names not specified use the **lowercase** |
| * normalized name. |
| * |
| * DOMAttributeNamespaces: object mapping React attribute name to the DOM |
| * attribute namespace URL. (Attribute names not specified use no namespace.) |
| * |
| * DOMPropertyNames: similar to DOMAttributeNames but for DOM properties. |
| * Property names not specified use the normalized name. |
| * |
| * DOMMutationMethods: Properties that require special mutation methods. If |
| * `value` is undefined, the mutation method should unset the property. |
| * |
| * @param {object} domPropertyConfig the config as described above. |
| */ |
| injectDOMPropertyConfig: function (domPropertyConfig) { |
| var Injection = DOMPropertyInjection; |
| var Properties = domPropertyConfig.Properties || {}; |
| var DOMAttributeNamespaces = domPropertyConfig.DOMAttributeNamespaces || {}; |
| var DOMAttributeNames = domPropertyConfig.DOMAttributeNames || {}; |
| var DOMPropertyNames = domPropertyConfig.DOMPropertyNames || {}; |
| var DOMMutationMethods = domPropertyConfig.DOMMutationMethods || {}; |
| |
| if (domPropertyConfig.isCustomAttribute) { |
| DOMProperty._isCustomAttributeFunctions.push(domPropertyConfig.isCustomAttribute); |
| } |
| |
| for (var propName in Properties) { |
| !!DOMProperty.properties.hasOwnProperty(propName) ? "development" !== 'production' ? invariant(false, 'injectDOMPropertyConfig(...): You\'re trying to inject DOM property ' + '\'%s\' which has already been injected. You may be accidentally ' + 'injecting the same DOM property config twice, or you may be ' + 'injecting two configs that have conflicting property names.', propName) : invariant(false) : undefined; |
| |
| var lowerCased = propName.toLowerCase(); |
| var propConfig = Properties[propName]; |
| |
| var propertyInfo = { |
| attributeName: lowerCased, |
| attributeNamespace: null, |
| propertyName: propName, |
| mutationMethod: null, |
| |
| mustUseAttribute: checkMask(propConfig, Injection.MUST_USE_ATTRIBUTE), |
| mustUseProperty: checkMask(propConfig, Injection.MUST_USE_PROPERTY), |
| hasSideEffects: checkMask(propConfig, Injection.HAS_SIDE_EFFECTS), |
| hasBooleanValue: checkMask(propConfig, Injection.HAS_BOOLEAN_VALUE), |
| hasNumericValue: checkMask(propConfig, Injection.HAS_NUMERIC_VALUE), |
| hasPositiveNumericValue: checkMask(propConfig, Injection.HAS_POSITIVE_NUMERIC_VALUE), |
| hasOverloadedBooleanValue: checkMask(propConfig, Injection.HAS_OVERLOADED_BOOLEAN_VALUE) |
| }; |
| |
| !(!propertyInfo.mustUseAttribute || !propertyInfo.mustUseProperty) ? "development" !== 'production' ? invariant(false, 'DOMProperty: Cannot require using both attribute and property: %s', propName) : invariant(false) : undefined; |
| !(propertyInfo.mustUseProperty || !propertyInfo.hasSideEffects) ? "development" !== 'production' ? invariant(false, 'DOMProperty: Properties that have side effects must use property: %s', propName) : invariant(false) : undefined; |
| !(propertyInfo.hasBooleanValue + propertyInfo.hasNumericValue + propertyInfo.hasOverloadedBooleanValue <= 1) ? "development" !== 'production' ? invariant(false, 'DOMProperty: Value can be one of boolean, overloaded boolean, or ' + 'numeric value, but not a combination: %s', propName) : invariant(false) : undefined; |
| |
| if ("development" !== 'production') { |
| DOMProperty.getPossibleStandardName[lowerCased] = propName; |
| } |
| |
| if (DOMAttributeNames.hasOwnProperty(propName)) { |
| var attributeName = DOMAttributeNames[propName]; |
| propertyInfo.attributeName = attributeName; |
| if ("development" !== 'production') { |
| DOMProperty.getPossibleStandardName[attributeName] = propName; |
| } |
| } |
| |
| if (DOMAttributeNamespaces.hasOwnProperty(propName)) { |
| propertyInfo.attributeNamespace = DOMAttributeNamespaces[propName]; |
| } |
| |
| if (DOMPropertyNames.hasOwnProperty(propName)) { |
| propertyInfo.propertyName = DOMPropertyNames[propName]; |
| } |
| |
| if (DOMMutationMethods.hasOwnProperty(propName)) { |
| propertyInfo.mutationMethod = DOMMutationMethods[propName]; |
| } |
| |
| DOMProperty.properties[propName] = propertyInfo; |
| } |
| } |
| }; |
| var defaultValueCache = {}; |
| |
| /** |
| * DOMProperty exports lookup objects that can be used like functions: |
| * |
| * > DOMProperty.isValid['id'] |
| * true |
| * > DOMProperty.isValid['foobar'] |
| * undefined |
| * |
| * Although this may be confusing, it performs better in general. |
| * |
| * @see http://jsperf.com/key-exists |
| * @see http://jsperf.com/key-missing |
| */ |
| var DOMProperty = { |
| |
| ID_ATTRIBUTE_NAME: 'data-reactid', |
| |
| /** |
| * Map from property "standard name" to an object with info about how to set |
| * the property in the DOM. Each object contains: |
| * |
| * attributeName: |
| * Used when rendering markup or with `*Attribute()`. |
| * attributeNamespace |
| * propertyName: |
| * Used on DOM node instances. (This includes properties that mutate due to |
| * external factors.) |
| * mutationMethod: |
| * If non-null, used instead of the property or `setAttribute()` after |
| * initial render. |
| * mustUseAttribute: |
| * Whether the property must be accessed and mutated using `*Attribute()`. |
| * (This includes anything that fails `<propName> in <element>`.) |
| * mustUseProperty: |
| * Whether the property must be accessed and mutated as an object property. |
| * hasSideEffects: |
| * Whether or not setting a value causes side effects such as triggering |
| * resources to be loaded or text selection changes. If true, we read from |
| * the DOM before updating to ensure that the value is only set if it has |
| * changed. |
| * hasBooleanValue: |
| * Whether the property should be removed when set to a falsey value. |
| * hasNumericValue: |
| * Whether the property must be numeric or parse as a numeric and should be |
| * removed when set to a falsey value. |
| * hasPositiveNumericValue: |
| * Whether the property must be positive numeric or parse as a positive |
| * numeric and should be removed when set to a falsey value. |
| * hasOverloadedBooleanValue: |
| * Whether the property can be used as a flag as well as with a value. |
| * Removed when strictly equal to false; present without a value when |
| * strictly equal to true; present with a value otherwise. |
| */ |
| properties: {}, |
| |
| /** |
| * Mapping from lowercase property names to the properly cased version, used |
| * to warn in the case of missing properties. Available only in __DEV__. |
| * @type {Object} |
| */ |
| getPossibleStandardName: "development" !== 'production' ? {} : null, |
| |
| /** |
| * All of the isCustomAttribute() functions that have been injected. |
| */ |
| _isCustomAttributeFunctions: [], |
| |
| /** |
| * Checks whether a property name is a custom attribute. |
| * @method |
| */ |
| isCustomAttribute: function (attributeName) { |
| for (var i = 0; i < DOMProperty._isCustomAttributeFunctions.length; i++) { |
| var isCustomAttributeFn = DOMProperty._isCustomAttributeFunctions[i]; |
| if (isCustomAttributeFn(attributeName)) { |
| return true; |
| } |
| } |
| return false; |
| }, |
| |
| /** |
| * Returns the default property value for a DOM property (i.e., not an |
| * attribute). Most default values are '' or false, but not all. Worse yet, |
| * some (in particular, `type`) vary depending on the type of element. |
| * |
| * TODO: Is it better to grab all the possible properties when creating an |
| * element to avoid having to create the same element twice? |
| */ |
| getDefaultValueForProperty: function (nodeName, prop) { |
| var nodeDefaults = defaultValueCache[nodeName]; |
| var testElement; |
| if (!nodeDefaults) { |
| defaultValueCache[nodeName] = nodeDefaults = {}; |
| } |
| if (!(prop in nodeDefaults)) { |
| testElement = document.createElement(nodeName); |
| nodeDefaults[prop] = testElement[prop]; |
| } |
| return nodeDefaults[prop]; |
| }, |
| |
| injection: DOMPropertyInjection |
| }; |
| |
| module.exports = DOMProperty; |
| },{"161":161}],11:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule DOMPropertyOperations |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| var ReactPerf = _dereq_(78); |
| |
| var quoteAttributeValueForBrowser = _dereq_(136); |
| var warning = _dereq_(173); |
| |
| // Simplified subset |
| var VALID_ATTRIBUTE_NAME_REGEX = /^[a-zA-Z_][\w\.\-]*$/; |
| var illegalAttributeNameCache = {}; |
| var validatedAttributeNameCache = {}; |
| |
| function isAttributeNameSafe(attributeName) { |
| if (validatedAttributeNameCache.hasOwnProperty(attributeName)) { |
| return true; |
| } |
| if (illegalAttributeNameCache.hasOwnProperty(attributeName)) { |
| return false; |
| } |
| if (VALID_ATTRIBUTE_NAME_REGEX.test(attributeName)) { |
| validatedAttributeNameCache[attributeName] = true; |
| return true; |
| } |
| illegalAttributeNameCache[attributeName] = true; |
| "development" !== 'production' ? warning(false, 'Invalid attribute name: `%s`', attributeName) : undefined; |
| return false; |
| } |
| |
| function shouldIgnoreValue(propertyInfo, value) { |
| return value == null || propertyInfo.hasBooleanValue && !value || propertyInfo.hasNumericValue && isNaN(value) || propertyInfo.hasPositiveNumericValue && value < 1 || propertyInfo.hasOverloadedBooleanValue && value === false; |
| } |
| |
| if ("development" !== 'production') { |
| var reactProps = { |
| children: true, |
| dangerouslySetInnerHTML: true, |
| key: true, |
| ref: true |
| }; |
| var warnedProperties = {}; |
| |
| var warnUnknownProperty = function (name) { |
| if (reactProps.hasOwnProperty(name) && reactProps[name] || warnedProperties.hasOwnProperty(name) && warnedProperties[name]) { |
| return; |
| } |
| |
| warnedProperties[name] = true; |
| var lowerCasedName = name.toLowerCase(); |
| |
| // data-* attributes should be lowercase; suggest the lowercase version |
| var standardName = DOMProperty.isCustomAttribute(lowerCasedName) ? lowerCasedName : DOMProperty.getPossibleStandardName.hasOwnProperty(lowerCasedName) ? DOMProperty.getPossibleStandardName[lowerCasedName] : null; |
| |
| // For now, only warn when we have a suggested correction. This prevents |
| // logging too much when using transferPropsTo. |
| "development" !== 'production' ? warning(standardName == null, 'Unknown DOM property %s. Did you mean %s?', name, standardName) : undefined; |
| }; |
| } |
| |
| /** |
| * Operations for dealing with DOM properties. |
| */ |
| var DOMPropertyOperations = { |
| |
| /** |
| * Creates markup for the ID property. |
| * |
| * @param {string} id Unescaped ID. |
| * @return {string} Markup string. |
| */ |
| createMarkupForID: function (id) { |
| return DOMProperty.ID_ATTRIBUTE_NAME + '=' + quoteAttributeValueForBrowser(id); |
| }, |
| |
| setAttributeForID: function (node, id) { |
| node.setAttribute(DOMProperty.ID_ATTRIBUTE_NAME, id); |
| }, |
| |
| /** |
| * Creates markup for a property. |
| * |
| * @param {string} name |
| * @param {*} value |
| * @return {?string} Markup string, or null if the property was invalid. |
| */ |
| createMarkupForProperty: function (name, value) { |
| var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null; |
| if (propertyInfo) { |
| if (shouldIgnoreValue(propertyInfo, value)) { |
| return ''; |
| } |
| var attributeName = propertyInfo.attributeName; |
| if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) { |
| return attributeName + '=""'; |
| } |
| return attributeName + '=' + quoteAttributeValueForBrowser(value); |
| } else if (DOMProperty.isCustomAttribute(name)) { |
| if (value == null) { |
| return ''; |
| } |
| return name + '=' + quoteAttributeValueForBrowser(value); |
| } else if ("development" !== 'production') { |
| warnUnknownProperty(name); |
| } |
| return null; |
| }, |
| |
| /** |
| * Creates markup for a custom property. |
| * |
| * @param {string} name |
| * @param {*} value |
| * @return {string} Markup string, or empty string if the property was invalid. |
| */ |
| createMarkupForCustomAttribute: function (name, value) { |
| if (!isAttributeNameSafe(name) || value == null) { |
| return ''; |
| } |
| return name + '=' + quoteAttributeValueForBrowser(value); |
| }, |
| |
| /** |
| * Sets the value for a property on a node. |
| * |
| * @param {DOMElement} node |
| * @param {string} name |
| * @param {*} value |
| */ |
| setValueForProperty: function (node, name, value) { |
| var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null; |
| if (propertyInfo) { |
| var mutationMethod = propertyInfo.mutationMethod; |
| if (mutationMethod) { |
| mutationMethod(node, value); |
| } else if (shouldIgnoreValue(propertyInfo, value)) { |
| this.deleteValueForProperty(node, name); |
| } else if (propertyInfo.mustUseAttribute) { |
| var attributeName = propertyInfo.attributeName; |
| var namespace = propertyInfo.attributeNamespace; |
| // `setAttribute` with objects becomes only `[object]` in IE8/9, |
| // ('' + value) makes it output the correct toString()-value. |
| if (namespace) { |
| node.setAttributeNS(namespace, attributeName, '' + value); |
| } else if (propertyInfo.hasBooleanValue || propertyInfo.hasOverloadedBooleanValue && value === true) { |
| node.setAttribute(attributeName, ''); |
| } else { |
| node.setAttribute(attributeName, '' + value); |
| } |
| } else { |
| var propName = propertyInfo.propertyName; |
| // Must explicitly cast values for HAS_SIDE_EFFECTS-properties to the |
| // property type before comparing; only `value` does and is string. |
| if (!propertyInfo.hasSideEffects || '' + node[propName] !== '' + value) { |
| // Contrary to `setAttribute`, object properties are properly |
| // `toString`ed by IE8/9. |
| node[propName] = value; |
| } |
| } |
| } else if (DOMProperty.isCustomAttribute(name)) { |
| DOMPropertyOperations.setValueForAttribute(node, name, value); |
| } else if ("development" !== 'production') { |
| warnUnknownProperty(name); |
| } |
| }, |
| |
| setValueForAttribute: function (node, name, value) { |
| if (!isAttributeNameSafe(name)) { |
| return; |
| } |
| if (value == null) { |
| node.removeAttribute(name); |
| } else { |
| node.setAttribute(name, '' + value); |
| } |
| }, |
| |
| /** |
| * Deletes the value for a property on a node. |
| * |
| * @param {DOMElement} node |
| * @param {string} name |
| */ |
| deleteValueForProperty: function (node, name) { |
| var propertyInfo = DOMProperty.properties.hasOwnProperty(name) ? DOMProperty.properties[name] : null; |
| if (propertyInfo) { |
| var mutationMethod = propertyInfo.mutationMethod; |
| if (mutationMethod) { |
| mutationMethod(node, undefined); |
| } else if (propertyInfo.mustUseAttribute) { |
| node.removeAttribute(propertyInfo.attributeName); |
| } else { |
| var propName = propertyInfo.propertyName; |
| var defaultValue = DOMProperty.getDefaultValueForProperty(node.nodeName, propName); |
| if (!propertyInfo.hasSideEffects || '' + node[propName] !== defaultValue) { |
| node[propName] = defaultValue; |
| } |
| } |
| } else if (DOMProperty.isCustomAttribute(name)) { |
| node.removeAttribute(name); |
| } else if ("development" !== 'production') { |
| warnUnknownProperty(name); |
| } |
| } |
| |
| }; |
| |
| ReactPerf.measureMethods(DOMPropertyOperations, 'DOMPropertyOperations', { |
| setValueForProperty: 'setValueForProperty', |
| setValueForAttribute: 'setValueForAttribute', |
| deleteValueForProperty: 'deleteValueForProperty' |
| }); |
| |
| module.exports = DOMPropertyOperations; |
| },{"10":10,"136":136,"173":173,"78":78}],12:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule Danger |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var createNodesFromMarkup = _dereq_(152); |
| var emptyFunction = _dereq_(153); |
| var getMarkupWrap = _dereq_(157); |
| var invariant = _dereq_(161); |
| |
| var OPEN_TAG_NAME_EXP = /^(<[^ \/>]+)/; |
| var RESULT_INDEX_ATTR = 'data-danger-index'; |
| |
| /** |
| * Extracts the `nodeName` from a string of markup. |
| * |
| * NOTE: Extracting the `nodeName` does not require a regular expression match |
| * because we make assumptions about React-generated markup (i.e. there are no |
| * spaces surrounding the opening tag and there is at least one attribute). |
| * |
| * @param {string} markup String of markup. |
| * @return {string} Node name of the supplied markup. |
| * @see http://jsperf.com/extract-nodename |
| */ |
| function getNodeName(markup) { |
| return markup.substring(1, markup.indexOf(' ')); |
| } |
| |
| var Danger = { |
| |
| /** |
| * Renders markup into an array of nodes. The markup is expected to render |
| * into a list of root nodes. Also, the length of `resultList` and |
| * `markupList` should be the same. |
| * |
| * @param {array<string>} markupList List of markup strings to render. |
| * @return {array<DOMElement>} List of rendered nodes. |
| * @internal |
| */ |
| dangerouslyRenderMarkup: function (markupList) { |
| !ExecutionEnvironment.canUseDOM ? "development" !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Cannot render markup in a worker ' + 'thread. Make sure `window` and `document` are available globally ' + 'before requiring React when unit testing or use ' + 'ReactDOMServer.renderToString for server rendering.') : invariant(false) : undefined; |
| var nodeName; |
| var markupByNodeName = {}; |
| // Group markup by `nodeName` if a wrap is necessary, else by '*'. |
| for (var i = 0; i < markupList.length; i++) { |
| !markupList[i] ? "development" !== 'production' ? invariant(false, 'dangerouslyRenderMarkup(...): Missing markup.') : invariant(false) : undefined; |
| nodeName = getNodeName(markupList[i]); |
| nodeName = getMarkupWrap(nodeName) ? nodeName : '*'; |
| markupByNodeName[nodeName] = markupByNodeName[nodeName] || []; |
| markupByNodeName[nodeName][i] = markupList[i]; |
| } |
| var resultList = []; |
| var resultListAssignmentCount = 0; |
| for (nodeName in markupByNodeName) { |
| if (!markupByNodeName.hasOwnProperty(nodeName)) { |
| continue; |
| } |
| var markupListByNodeName = markupByNodeName[nodeName]; |
| |
| // This for-in loop skips the holes of the sparse array. The order of |
| // iteration should follow the order of assignment, which happens to match |
| // numerical index order, but we don't rely on that. |
| var resultIndex; |
| for (resultIndex in markupListByNodeName) { |
| if (markupListByNodeName.hasOwnProperty(resultIndex)) { |
| var markup = markupListByNodeName[resultIndex]; |
| |
| // Push the requested markup with an additional RESULT_INDEX_ATTR |
| // attribute. If the markup does not start with a < character, it |
| // will be discarded below (with an appropriate console.error). |
| markupListByNodeName[resultIndex] = markup.replace(OPEN_TAG_NAME_EXP, |
| // This index will be parsed back out below. |
| '$1 ' + RESULT_INDEX_ATTR + '="' + resultIndex + '" '); |
| } |
| } |
| |
| // Render each group of markup with similar wrapping `nodeName`. |
| var renderNodes = createNodesFromMarkup(markupListByNodeName.join(''), emptyFunction // Do nothing special with <script> tags. |
| ); |
| |
| for (var j = 0; j < renderNodes.length; ++j) { |
| var renderNode = renderNodes[j]; |
| if (renderNode.hasAttribute && renderNode.hasAttribute(RESULT_INDEX_ATTR)) { |
| |
| resultIndex = +renderNode.getAttribute(RESULT_INDEX_ATTR); |
| renderNode.removeAttribute(RESULT_INDEX_ATTR); |
| |
| !!resultList.hasOwnProperty(resultIndex) ? "development" !== 'production' ? invariant(false, 'Danger: Assigning to an already-occupied result index.') : invariant(false) : undefined; |
| |
| resultList[resultIndex] = renderNode; |
| |
| // This should match resultList.length and markupList.length when |
| // we're done. |
| resultListAssignmentCount += 1; |
| } else if ("development" !== 'production') { |
| console.error('Danger: Discarding unexpected node:', renderNode); |
| } |
| } |
| } |
| |
| // Although resultList was populated out of order, it should now be a dense |
| // array. |
| !(resultListAssignmentCount === resultList.length) ? "development" !== 'production' ? invariant(false, 'Danger: Did not assign to every index of resultList.') : invariant(false) : undefined; |
| |
| !(resultList.length === markupList.length) ? "development" !== 'production' ? invariant(false, 'Danger: Expected markup to render %s nodes, but rendered %s.', markupList.length, resultList.length) : invariant(false) : undefined; |
| |
| return resultList; |
| }, |
| |
| /** |
| * Replaces a node with a string of markup at its current position within its |
| * parent. The markup must render into a single root node. |
| * |
| * @param {DOMElement} oldChild Child node to replace. |
| * @param {string} markup Markup to render in place of the child node. |
| * @internal |
| */ |
| dangerouslyReplaceNodeWithMarkup: function (oldChild, markup) { |
| !ExecutionEnvironment.canUseDOM ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot render markup in a ' + 'worker thread. Make sure `window` and `document` are available ' + 'globally before requiring React when unit testing or use ' + 'ReactDOMServer.renderToString() for server rendering.') : invariant(false) : undefined; |
| !markup ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Missing markup.') : invariant(false) : undefined; |
| !(oldChild.tagName.toLowerCase() !== 'html') ? "development" !== 'production' ? invariant(false, 'dangerouslyReplaceNodeWithMarkup(...): Cannot replace markup of the ' + '<html> node. This is because browser quirks make this unreliable ' + 'and/or slow. If you want to render to the root you must use ' + 'server rendering. See ReactDOMServer.renderToString().') : invariant(false) : undefined; |
| |
| var newChild; |
| if (typeof markup === 'string') { |
| newChild = createNodesFromMarkup(markup, emptyFunction)[0]; |
| } else { |
| newChild = markup; |
| } |
| oldChild.parentNode.replaceChild(newChild, oldChild); |
| } |
| |
| }; |
| |
| module.exports = Danger; |
| },{"147":147,"152":152,"153":153,"157":157,"161":161}],13:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule DefaultEventPluginOrder |
| */ |
| |
| 'use strict'; |
| |
| var keyOf = _dereq_(166); |
| |
| /** |
| * Module that is injectable into `EventPluginHub`, that specifies a |
| * deterministic ordering of `EventPlugin`s. A convenient way to reason about |
| * plugins, without having to package every one of them. This is better than |
| * having plugins be ordered in the same order that they are injected because |
| * that ordering would be influenced by the packaging order. |
| * `ResponderEventPlugin` must occur before `SimpleEventPlugin` so that |
| * preventing default on events is convenient in `SimpleEventPlugin` handlers. |
| */ |
| var DefaultEventPluginOrder = [keyOf({ ResponderEventPlugin: null }), keyOf({ SimpleEventPlugin: null }), keyOf({ TapEventPlugin: null }), keyOf({ EnterLeaveEventPlugin: null }), keyOf({ ChangeEventPlugin: null }), keyOf({ SelectEventPlugin: null }), keyOf({ BeforeInputEventPlugin: null })]; |
| |
| module.exports = DefaultEventPluginOrder; |
| },{"166":166}],14:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EnterLeaveEventPlugin |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPropagators = _dereq_(19); |
| var SyntheticMouseEvent = _dereq_(109); |
| |
| var ReactMount = _dereq_(72); |
| var keyOf = _dereq_(166); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| var getFirstReactDOM = ReactMount.getFirstReactDOM; |
| |
| var eventTypes = { |
| mouseEnter: { |
| registrationName: keyOf({ onMouseEnter: null }), |
| dependencies: [topLevelTypes.topMouseOut, topLevelTypes.topMouseOver] |
| }, |
| mouseLeave: { |
| registrationName: keyOf({ onMouseLeave: null }), |
| dependencies: [topLevelTypes.topMouseOut, topLevelTypes.topMouseOver] |
| } |
| }; |
| |
| var extractedEvents = [null, null]; |
| |
| var EnterLeaveEventPlugin = { |
| |
| eventTypes: eventTypes, |
| |
| /** |
| * For almost every interaction we care about, there will be both a top-level |
| * `mouseover` and `mouseout` event that occurs. Only use `mouseout` so that |
| * we do not extract duplicate events. However, moving the mouse into the |
| * browser from outside will not fire a `mouseout` event. In this case, we use |
| * the `mouseover` top-level event. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @see {EventPluginHub.extractEvents} |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| if (topLevelType === topLevelTypes.topMouseOver && (nativeEvent.relatedTarget || nativeEvent.fromElement)) { |
| return null; |
| } |
| if (topLevelType !== topLevelTypes.topMouseOut && topLevelType !== topLevelTypes.topMouseOver) { |
| // Must not be a mouse in or mouse out - ignoring. |
| return null; |
| } |
| |
| var win; |
| if (topLevelTarget.window === topLevelTarget) { |
| // `topLevelTarget` is probably a window object. |
| win = topLevelTarget; |
| } else { |
| // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8. |
| var doc = topLevelTarget.ownerDocument; |
| if (doc) { |
| win = doc.defaultView || doc.parentWindow; |
| } else { |
| win = window; |
| } |
| } |
| |
| var from; |
| var to; |
| var fromID = ''; |
| var toID = ''; |
| if (topLevelType === topLevelTypes.topMouseOut) { |
| from = topLevelTarget; |
| fromID = topLevelTargetID; |
| to = getFirstReactDOM(nativeEvent.relatedTarget || nativeEvent.toElement); |
| if (to) { |
| toID = ReactMount.getID(to); |
| } else { |
| to = win; |
| } |
| to = to || win; |
| } else { |
| from = win; |
| to = topLevelTarget; |
| toID = topLevelTargetID; |
| } |
| |
| if (from === to) { |
| // Nothing pertains to our managed components. |
| return null; |
| } |
| |
| var leave = SyntheticMouseEvent.getPooled(eventTypes.mouseLeave, fromID, nativeEvent, nativeEventTarget); |
| leave.type = 'mouseleave'; |
| leave.target = from; |
| leave.relatedTarget = to; |
| |
| var enter = SyntheticMouseEvent.getPooled(eventTypes.mouseEnter, toID, nativeEvent, nativeEventTarget); |
| enter.type = 'mouseenter'; |
| enter.target = to; |
| enter.relatedTarget = from; |
| |
| EventPropagators.accumulateEnterLeaveDispatches(leave, enter, fromID, toID); |
| |
| extractedEvents[0] = leave; |
| extractedEvents[1] = enter; |
| |
| return extractedEvents; |
| } |
| |
| }; |
| |
| module.exports = EnterLeaveEventPlugin; |
| },{"109":109,"15":15,"166":166,"19":19,"72":72}],15:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EventConstants |
| */ |
| |
| 'use strict'; |
| |
| var keyMirror = _dereq_(165); |
| |
| var PropagationPhases = keyMirror({ bubbled: null, captured: null }); |
| |
| /** |
| * Types of raw signals from the browser caught at the top level. |
| */ |
| var topLevelTypes = keyMirror({ |
| topAbort: null, |
| topBlur: null, |
| topCanPlay: null, |
| topCanPlayThrough: null, |
| topChange: null, |
| topClick: null, |
| topCompositionEnd: null, |
| topCompositionStart: null, |
| topCompositionUpdate: null, |
| topContextMenu: null, |
| topCopy: null, |
| topCut: null, |
| topDoubleClick: null, |
| topDrag: null, |
| topDragEnd: null, |
| topDragEnter: null, |
| topDragExit: null, |
| topDragLeave: null, |
| topDragOver: null, |
| topDragStart: null, |
| topDrop: null, |
| topDurationChange: null, |
| topEmptied: null, |
| topEncrypted: null, |
| topEnded: null, |
| topError: null, |
| topFocus: null, |
| topInput: null, |
| topKeyDown: null, |
| topKeyPress: null, |
| topKeyUp: null, |
| topLoad: null, |
| topLoadedData: null, |
| topLoadedMetadata: null, |
| topLoadStart: null, |
| topMouseDown: null, |
| topMouseMove: null, |
| topMouseOut: null, |
| topMouseOver: null, |
| topMouseUp: null, |
| topPaste: null, |
| topPause: null, |
| topPlay: null, |
| topPlaying: null, |
| topProgress: null, |
| topRateChange: null, |
| topReset: null, |
| topScroll: null, |
| topSeeked: null, |
| topSeeking: null, |
| topSelectionChange: null, |
| topStalled: null, |
| topSubmit: null, |
| topSuspend: null, |
| topTextInput: null, |
| topTimeUpdate: null, |
| topTouchCancel: null, |
| topTouchEnd: null, |
| topTouchMove: null, |
| topTouchStart: null, |
| topVolumeChange: null, |
| topWaiting: null, |
| topWheel: null |
| }); |
| |
| var EventConstants = { |
| topLevelTypes: topLevelTypes, |
| PropagationPhases: PropagationPhases |
| }; |
| |
| module.exports = EventConstants; |
| },{"165":165}],16:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EventPluginHub |
| */ |
| |
| 'use strict'; |
| |
| var EventPluginRegistry = _dereq_(17); |
| var EventPluginUtils = _dereq_(18); |
| var ReactErrorUtils = _dereq_(61); |
| |
| var accumulateInto = _dereq_(115); |
| var forEachAccumulated = _dereq_(124); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| /** |
| * Internal store for event listeners |
| */ |
| var listenerBank = {}; |
| |
| /** |
| * Internal queue of events that have accumulated their dispatches and are |
| * waiting to have their dispatches executed. |
| */ |
| var eventQueue = null; |
| |
| /** |
| * 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 |
| */ |
| var executeDispatchesAndRelease = function (event, simulated) { |
| if (event) { |
| EventPluginUtils.executeDispatchesInOrder(event, simulated); |
| |
| if (!event.isPersistent()) { |
| event.constructor.release(event); |
| } |
| } |
| }; |
| var executeDispatchesAndReleaseSimulated = function (e) { |
| return executeDispatchesAndRelease(e, true); |
| }; |
| var executeDispatchesAndReleaseTopLevel = function (e) { |
| return executeDispatchesAndRelease(e, false); |
| }; |
| |
| /** |
| * - `InstanceHandle`: [required] Module that performs logical traversals of DOM |
| * hierarchy given ids of the logical DOM elements involved. |
| */ |
| var InstanceHandle = null; |
| |
| function validateInstanceHandle() { |
| var valid = InstanceHandle && InstanceHandle.traverseTwoPhase && InstanceHandle.traverseEnterLeave; |
| "development" !== 'production' ? warning(valid, 'InstanceHandle not injected before use!') : undefined; |
| } |
| |
| /** |
| * This is a unified interface for event plugins to be installed and configured. |
| * |
| * Event plugins can implement the following properties: |
| * |
| * `extractEvents` {function(string, DOMEventTarget, string, object): *} |
| * Required. When a top-level event is fired, this method is expected to |
| * extract synthetic events that will in turn be queued and dispatched. |
| * |
| * `eventTypes` {object} |
| * Optional, plugins that fire events must publish a mapping of registration |
| * names that are used to register listeners. Values of this mapping must |
| * be objects that contain `registrationName` or `phasedRegistrationNames`. |
| * |
| * `executeDispatch` {function(object, function, string)} |
| * Optional, allows plugins to override how an event gets dispatched. By |
| * default, the listener is simply invoked. |
| * |
| * Each plugin that is injected into `EventsPluginHub` is immediately operable. |
| * |
| * @public |
| */ |
| var EventPluginHub = { |
| |
| /** |
| * Methods for injecting dependencies. |
| */ |
| injection: { |
| |
| /** |
| * @param {object} InjectedMount |
| * @public |
| */ |
| injectMount: EventPluginUtils.injection.injectMount, |
| |
| /** |
| * @param {object} InjectedInstanceHandle |
| * @public |
| */ |
| injectInstanceHandle: function (InjectedInstanceHandle) { |
| InstanceHandle = InjectedInstanceHandle; |
| if ("development" !== 'production') { |
| validateInstanceHandle(); |
| } |
| }, |
| |
| getInstanceHandle: function () { |
| if ("development" !== 'production') { |
| validateInstanceHandle(); |
| } |
| return InstanceHandle; |
| }, |
| |
| /** |
| * @param {array} InjectedEventPluginOrder |
| * @public |
| */ |
| injectEventPluginOrder: EventPluginRegistry.injectEventPluginOrder, |
| |
| /** |
| * @param {object} injectedNamesToPlugins Map from names to plugin modules. |
| */ |
| injectEventPluginsByName: EventPluginRegistry.injectEventPluginsByName |
| |
| }, |
| |
| eventNameDispatchConfigs: EventPluginRegistry.eventNameDispatchConfigs, |
| |
| registrationNameModules: EventPluginRegistry.registrationNameModules, |
| |
| /** |
| * Stores `listener` at `listenerBank[registrationName][id]`. Is idempotent. |
| * |
| * @param {string} id ID of the DOM element. |
| * @param {string} registrationName Name of listener (e.g. `onClick`). |
| * @param {?function} listener The callback to store. |
| */ |
| putListener: function (id, registrationName, listener) { |
| !(typeof listener === 'function') ? "development" !== 'production' ? invariant(false, 'Expected %s listener to be a function, instead got type %s', registrationName, typeof listener) : invariant(false) : undefined; |
| |
| var bankForRegistrationName = listenerBank[registrationName] || (listenerBank[registrationName] = {}); |
| bankForRegistrationName[id] = listener; |
| |
| var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; |
| if (PluginModule && PluginModule.didPutListener) { |
| PluginModule.didPutListener(id, registrationName, listener); |
| } |
| }, |
| |
| /** |
| * @param {string} id ID of the DOM element. |
| * @param {string} registrationName Name of listener (e.g. `onClick`). |
| * @return {?function} The stored callback. |
| */ |
| getListener: function (id, registrationName) { |
| var bankForRegistrationName = listenerBank[registrationName]; |
| return bankForRegistrationName && bankForRegistrationName[id]; |
| }, |
| |
| /** |
| * Deletes a listener from the registration bank. |
| * |
| * @param {string} id ID of the DOM element. |
| * @param {string} registrationName Name of listener (e.g. `onClick`). |
| */ |
| deleteListener: function (id, registrationName) { |
| var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; |
| if (PluginModule && PluginModule.willDeleteListener) { |
| PluginModule.willDeleteListener(id, registrationName); |
| } |
| |
| var bankForRegistrationName = listenerBank[registrationName]; |
| // TODO: This should never be null -- when is it? |
| if (bankForRegistrationName) { |
| delete bankForRegistrationName[id]; |
| } |
| }, |
| |
| /** |
| * Deletes all listeners for the DOM element with the supplied ID. |
| * |
| * @param {string} id ID of the DOM element. |
| */ |
| deleteAllListeners: function (id) { |
| for (var registrationName in listenerBank) { |
| if (!listenerBank[registrationName][id]) { |
| continue; |
| } |
| |
| var PluginModule = EventPluginRegistry.registrationNameModules[registrationName]; |
| if (PluginModule && PluginModule.willDeleteListener) { |
| PluginModule.willDeleteListener(id, registrationName); |
| } |
| |
| delete listenerBank[registrationName][id]; |
| } |
| }, |
| |
| /** |
| * Allows registered plugins an opportunity to extract events from top-level |
| * native browser events. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @internal |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| var events; |
| var plugins = EventPluginRegistry.plugins; |
| for (var i = 0; i < plugins.length; i++) { |
| // Not every plugin in the ordering may be loaded at runtime. |
| var possiblePlugin = plugins[i]; |
| if (possiblePlugin) { |
| var extractedEvents = possiblePlugin.extractEvents(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget); |
| if (extractedEvents) { |
| events = accumulateInto(events, extractedEvents); |
| } |
| } |
| } |
| return events; |
| }, |
| |
| /** |
| * Enqueues a synthetic event that should be dispatched when |
| * `processEventQueue` is invoked. |
| * |
| * @param {*} events An accumulation of synthetic events. |
| * @internal |
| */ |
| enqueueEvents: function (events) { |
| if (events) { |
| eventQueue = accumulateInto(eventQueue, events); |
| } |
| }, |
| |
| /** |
| * Dispatches all synthetic events on the event queue. |
| * |
| * @internal |
| */ |
| processEventQueue: function (simulated) { |
| // Set `eventQueue` to null before processing it so that we can tell if more |
| // events get enqueued while processing. |
| var processingEventQueue = eventQueue; |
| eventQueue = null; |
| if (simulated) { |
| forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseSimulated); |
| } else { |
| forEachAccumulated(processingEventQueue, executeDispatchesAndReleaseTopLevel); |
| } |
| !!eventQueue ? "development" !== 'production' ? invariant(false, 'processEventQueue(): Additional events were enqueued while processing ' + 'an event queue. Support for this has not yet been implemented.') : invariant(false) : undefined; |
| // This would be a good time to rethrow if any of the event handlers threw. |
| ReactErrorUtils.rethrowCaughtError(); |
| }, |
| |
| /** |
| * These are needed for tests only. Do not use! |
| */ |
| __purge: function () { |
| listenerBank = {}; |
| }, |
| |
| __getListenerBank: function () { |
| return listenerBank; |
| } |
| |
| }; |
| |
| module.exports = EventPluginHub; |
| },{"115":115,"124":124,"161":161,"17":17,"173":173,"18":18,"61":61}],17:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EventPluginRegistry |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Injectable ordering of event plugins. |
| */ |
| var EventPluginOrder = null; |
| |
| /** |
| * Injectable mapping from names to event plugin modules. |
| */ |
| var namesToPlugins = {}; |
| |
| /** |
| * Recomputes the plugin list using the injected plugins and plugin ordering. |
| * |
| * @private |
| */ |
| 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) ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugins that do not exist in ' + 'the plugin ordering, `%s`.', pluginName) : invariant(false) : undefined; |
| if (EventPluginRegistry.plugins[pluginIndex]) { |
| continue; |
| } |
| !PluginModule.extractEvents ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Event plugins must implement an `extractEvents` ' + 'method, but `%s` does not.', pluginName) : invariant(false) : undefined; |
| EventPluginRegistry.plugins[pluginIndex] = PluginModule; |
| var publishedEvents = PluginModule.eventTypes; |
| for (var eventName in publishedEvents) { |
| !publishEventForPlugin(publishedEvents[eventName], PluginModule, eventName) ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Failed to publish event `%s` for plugin `%s`.', eventName, pluginName) : invariant(false) : undefined; |
| } |
| } |
| } |
| |
| /** |
| * 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 |
| */ |
| function publishEventForPlugin(dispatchConfig, PluginModule, eventName) { |
| !!EventPluginRegistry.eventNameDispatchConfigs.hasOwnProperty(eventName) ? "development" !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same ' + 'event name, `%s`.', eventName) : invariant(false) : undefined; |
| 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 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 |
| */ |
| function publishRegistrationName(registrationName, PluginModule, eventName) { |
| !!EventPluginRegistry.registrationNameModules[registrationName] ? "development" !== 'production' ? invariant(false, 'EventPluginHub: More than one plugin attempted to publish the same ' + 'registration name, `%s`.', registrationName) : invariant(false) : undefined; |
| EventPluginRegistry.registrationNameModules[registrationName] = PluginModule; |
| EventPluginRegistry.registrationNameDependencies[registrationName] = PluginModule.eventTypes[eventName].dependencies; |
| } |
| |
| /** |
| * Registers plugins so that they can extract and dispatch events. |
| * |
| * @see {EventPluginHub} |
| */ |
| var EventPluginRegistry = { |
| |
| /** |
| * Ordered list of injected plugins. |
| */ |
| plugins: [], |
| |
| /** |
| * Mapping from event name to dispatch config |
| */ |
| eventNameDispatchConfigs: {}, |
| |
| /** |
| * Mapping from registration name to plugin module |
| */ |
| registrationNameModules: {}, |
| |
| /** |
| * Mapping from registration name to event name |
| */ |
| registrationNameDependencies: {}, |
| |
| /** |
| * Injects an ordering of plugins (by plugin name). This allows the ordering |
| * to be decoupled from injection of the actual plugins so that ordering is |
| * always deterministic regardless of packaging, on-the-fly injection, etc. |
| * |
| * @param {array} InjectedEventPluginOrder |
| * @internal |
| * @see {EventPluginHub.injection.injectEventPluginOrder} |
| */ |
| injectEventPluginOrder: function (InjectedEventPluginOrder) { |
| !!EventPluginOrder ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject event plugin ordering more than ' + 'once. You are likely trying to load more than one copy of React.') : invariant(false) : undefined; |
| // Clone the ordering so it cannot be dynamically mutated. |
| EventPluginOrder = Array.prototype.slice.call(InjectedEventPluginOrder); |
| recomputePluginOrdering(); |
| }, |
| |
| /** |
| * Injects plugins to be used by `EventPluginHub`. The plugin names must be |
| * in the ordering injected by `injectEventPluginOrder`. |
| * |
| * Plugins can be injected as part of page initialization or on-the-fly. |
| * |
| * @param {object} injectedNamesToPlugins Map from names to plugin modules. |
| * @internal |
| * @see {EventPluginHub.injection.injectEventPluginsByName} |
| */ |
| injectEventPluginsByName: function (injectedNamesToPlugins) { |
| var isOrderingDirty = false; |
| for (var pluginName in injectedNamesToPlugins) { |
| if (!injectedNamesToPlugins.hasOwnProperty(pluginName)) { |
| continue; |
| } |
| var PluginModule = injectedNamesToPlugins[pluginName]; |
| if (!namesToPlugins.hasOwnProperty(pluginName) || namesToPlugins[pluginName] !== PluginModule) { |
| !!namesToPlugins[pluginName] ? "development" !== 'production' ? invariant(false, 'EventPluginRegistry: Cannot inject two different event plugins ' + 'using the same name, `%s`.', pluginName) : invariant(false) : undefined; |
| namesToPlugins[pluginName] = PluginModule; |
| isOrderingDirty = true; |
| } |
| } |
| if (isOrderingDirty) { |
| recomputePluginOrdering(); |
| } |
| }, |
| |
| /** |
| * Looks up the plugin for the supplied event. |
| * |
| * @param {object} event A synthetic event. |
| * @return {?object} The plugin that created the supplied event. |
| * @internal |
| */ |
| getPluginModuleForEvent: function (event) { |
| var dispatchConfig = event.dispatchConfig; |
| if (dispatchConfig.registrationName) { |
| return EventPluginRegistry.registrationNameModules[dispatchConfig.registrationName] || null; |
| } |
| for (var phase in dispatchConfig.phasedRegistrationNames) { |
| if (!dispatchConfig.phasedRegistrationNames.hasOwnProperty(phase)) { |
| continue; |
| } |
| var PluginModule = EventPluginRegistry.registrationNameModules[dispatchConfig.phasedRegistrationNames[phase]]; |
| if (PluginModule) { |
| return PluginModule; |
| } |
| } |
| return null; |
| }, |
| |
| /** |
| * Exposed for unit testing. |
| * @private |
| */ |
| _resetEventPlugins: function () { |
| EventPluginOrder = null; |
| for (var pluginName in namesToPlugins) { |
| if (namesToPlugins.hasOwnProperty(pluginName)) { |
| delete namesToPlugins[pluginName]; |
| } |
| } |
| EventPluginRegistry.plugins.length = 0; |
| |
| var eventNameDispatchConfigs = EventPluginRegistry.eventNameDispatchConfigs; |
| for (var eventName in eventNameDispatchConfigs) { |
| if (eventNameDispatchConfigs.hasOwnProperty(eventName)) { |
| delete eventNameDispatchConfigs[eventName]; |
| } |
| } |
| |
| var registrationNameModules = EventPluginRegistry.registrationNameModules; |
| for (var registrationName in registrationNameModules) { |
| if (registrationNameModules.hasOwnProperty(registrationName)) { |
| delete registrationNameModules[registrationName]; |
| } |
| } |
| } |
| |
| }; |
| |
| module.exports = EventPluginRegistry; |
| },{"161":161}],18:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EventPluginUtils |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var ReactErrorUtils = _dereq_(61); |
| |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| /** |
| * Injected dependencies: |
| */ |
| |
| /** |
| * - `Mount`: [required] Module that can convert between React dom IDs and |
| * actual node references. |
| */ |
| var injection = { |
| Mount: null, |
| injectMount: function (InjectedMount) { |
| injection.Mount = InjectedMount; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(InjectedMount && InjectedMount.getNode && InjectedMount.getID, 'EventPluginUtils.injection.injectMount(...): Injected Mount ' + 'module is missing getNode or getID.') : undefined; |
| } |
| } |
| }; |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| function isEndish(topLevelType) { |
| return topLevelType === topLevelTypes.topMouseUp || topLevelType === topLevelTypes.topTouchEnd || topLevelType === topLevelTypes.topTouchCancel; |
| } |
| |
| function isMoveish(topLevelType) { |
| return topLevelType === topLevelTypes.topMouseMove || topLevelType === topLevelTypes.topTouchMove; |
| } |
| function isStartish(topLevelType) { |
| return topLevelType === topLevelTypes.topMouseDown || topLevelType === topLevelTypes.topTouchStart; |
| } |
| |
| var validateEventDispatches; |
| if ("development" !== 'production') { |
| validateEventDispatches = function (event) { |
| var dispatchListeners = event._dispatchListeners; |
| var dispatchIDs = event._dispatchIDs; |
| |
| var listenersIsArr = Array.isArray(dispatchListeners); |
| var idsIsArr = Array.isArray(dispatchIDs); |
| var IDsLen = idsIsArr ? dispatchIDs.length : dispatchIDs ? 1 : 0; |
| var listenersLen = listenersIsArr ? dispatchListeners.length : dispatchListeners ? 1 : 0; |
| |
| "development" !== 'production' ? warning(idsIsArr === listenersIsArr && IDsLen === listenersLen, 'EventPluginUtils: Invalid `event`.') : undefined; |
| }; |
| } |
| |
| /** |
| * 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 {string} domID DOM id to pass to the callback. |
| */ |
| function executeDispatch(event, simulated, listener, domID) { |
| var type = event.type || 'unknown-event'; |
| event.currentTarget = injection.Mount.getNode(domID); |
| if (simulated) { |
| ReactErrorUtils.invokeGuardedCallbackWithCatch(type, listener, event, domID); |
| } else { |
| ReactErrorUtils.invokeGuardedCallback(type, listener, event, domID); |
| } |
| event.currentTarget = null; |
| } |
| |
| /** |
| * Standard/simple iteration through an event's collected dispatches. |
| */ |
| function executeDispatchesInOrder(event, simulated) { |
| var dispatchListeners = event._dispatchListeners; |
| var dispatchIDs = event._dispatchIDs; |
| if ("development" !== 'production') { |
| validateEventDispatches(event); |
| } |
| if (Array.isArray(dispatchListeners)) { |
| for (var i = 0; i < dispatchListeners.length; i++) { |
| if (event.isPropagationStopped()) { |
| break; |
| } |
| // Listeners and IDs are two parallel arrays that are always in sync. |
| executeDispatch(event, simulated, dispatchListeners[i], dispatchIDs[i]); |
| } |
| } else if (dispatchListeners) { |
| executeDispatch(event, simulated, dispatchListeners, dispatchIDs); |
| } |
| event._dispatchListeners = null; |
| event._dispatchIDs = 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. |
| */ |
| function executeDispatchesInOrderStopAtTrueImpl(event) { |
| var dispatchListeners = event._dispatchListeners; |
| var dispatchIDs = event._dispatchIDs; |
| if ("development" !== 'production') { |
| validateEventDispatches(event); |
| } |
| if (Array.isArray(dispatchListeners)) { |
| for (var i = 0; i < dispatchListeners.length; i++) { |
| if (event.isPropagationStopped()) { |
| break; |
| } |
| // Listeners and IDs are two parallel arrays that are always in sync. |
| if (dispatchListeners[i](event, dispatchIDs[i])) { |
| return dispatchIDs[i]; |
| } |
| } |
| } else if (dispatchListeners) { |
| if (dispatchListeners(event, dispatchIDs)) { |
| return dispatchIDs; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * @see executeDispatchesInOrderStopAtTrueImpl |
| */ |
| function executeDispatchesInOrderStopAtTrue(event) { |
| var ret = executeDispatchesInOrderStopAtTrueImpl(event); |
| event._dispatchIDs = null; |
| event._dispatchListeners = null; |
| return ret; |
| } |
| |
| /** |
| * 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. |
| */ |
| function executeDirectDispatch(event) { |
| if ("development" !== 'production') { |
| validateEventDispatches(event); |
| } |
| var dispatchListener = event._dispatchListeners; |
| var dispatchID = event._dispatchIDs; |
| !!Array.isArray(dispatchListener) ? "development" !== 'production' ? invariant(false, 'executeDirectDispatch(...): Invalid `event`.') : invariant(false) : undefined; |
| var res = dispatchListener ? dispatchListener(event, dispatchID) : null; |
| event._dispatchListeners = null; |
| event._dispatchIDs = null; |
| return res; |
| } |
| |
| /** |
| * @param {SyntheticEvent} event |
| * @return {boolean} True iff number of dispatches accumulated is greater than 0. |
| */ |
| function hasDispatches(event) { |
| return !!event._dispatchListeners; |
| } |
| |
| /** |
| * General utilities that are useful in creating custom Event Plugins. |
| */ |
| var EventPluginUtils = { |
| isEndish: isEndish, |
| isMoveish: isMoveish, |
| isStartish: isStartish, |
| |
| executeDirectDispatch: executeDirectDispatch, |
| executeDispatchesInOrder: executeDispatchesInOrder, |
| executeDispatchesInOrderStopAtTrue: executeDispatchesInOrderStopAtTrue, |
| hasDispatches: hasDispatches, |
| |
| getNode: function (id) { |
| return injection.Mount.getNode(id); |
| }, |
| getID: function (node) { |
| return injection.Mount.getID(node); |
| }, |
| |
| injection: injection |
| }; |
| |
| module.exports = EventPluginUtils; |
| },{"15":15,"161":161,"173":173,"61":61}],19:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule EventPropagators |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPluginHub = _dereq_(16); |
| |
| var warning = _dereq_(173); |
| |
| var accumulateInto = _dereq_(115); |
| var forEachAccumulated = _dereq_(124); |
| |
| var PropagationPhases = EventConstants.PropagationPhases; |
| var getListener = EventPluginHub.getListener; |
| |
| /** |
| * Some event types have a notion of different registration names for different |
| * "phases" of propagation. This finds listeners by a given phase. |
| */ |
| function listenerAtPhase(id, event, propagationPhase) { |
| var registrationName = event.dispatchConfig.phasedRegistrationNames[propagationPhase]; |
| return getListener(id, registrationName); |
| } |
| |
| /** |
| * 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. |
| */ |
| function accumulateDirectionalDispatches(domID, upwards, event) { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(domID, 'Dispatching id must not be null') : undefined; |
| } |
| var phase = upwards ? PropagationPhases.bubbled : PropagationPhases.captured; |
| var listener = listenerAtPhase(domID, event, phase); |
| if (listener) { |
| event._dispatchListeners = accumulateInto(event._dispatchListeners, listener); |
| event._dispatchIDs = accumulateInto(event._dispatchIDs, domID); |
| } |
| } |
| |
| /** |
| * 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. |
| */ |
| function accumulateTwoPhaseDispatchesSingle(event) { |
| if (event && event.dispatchConfig.phasedRegistrationNames) { |
| EventPluginHub.injection.getInstanceHandle().traverseTwoPhase(event.dispatchMarker, accumulateDirectionalDispatches, event); |
| } |
| } |
| |
| /** |
| * Same as `accumulateTwoPhaseDispatchesSingle`, but skips over the targetID. |
| */ |
| function accumulateTwoPhaseDispatchesSingleSkipTarget(event) { |
| if (event && event.dispatchConfig.phasedRegistrationNames) { |
| EventPluginHub.injection.getInstanceHandle().traverseTwoPhaseSkipTarget(event.dispatchMarker, accumulateDirectionalDispatches, event); |
| } |
| } |
| |
| /** |
| * 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. |
| */ |
| function accumulateDispatches(id, ignoredDirection, event) { |
| if (event && event.dispatchConfig.registrationName) { |
| var registrationName = event.dispatchConfig.registrationName; |
| var listener = getListener(id, registrationName); |
| if (listener) { |
| event._dispatchListeners = accumulateInto(event._dispatchListeners, listener); |
| event._dispatchIDs = accumulateInto(event._dispatchIDs, id); |
| } |
| } |
| } |
| |
| /** |
| * Accumulates dispatches on an `SyntheticEvent`, but only for the |
| * `dispatchMarker`. |
| * @param {SyntheticEvent} event |
| */ |
| function accumulateDirectDispatchesSingle(event) { |
| if (event && event.dispatchConfig.registrationName) { |
| accumulateDispatches(event.dispatchMarker, null, event); |
| } |
| } |
| |
| function accumulateTwoPhaseDispatches(events) { |
| forEachAccumulated(events, accumulateTwoPhaseDispatchesSingle); |
| } |
| |
| function accumulateTwoPhaseDispatchesSkipTarget(events) { |
| forEachAccumulated(events, accumulateTwoPhaseDispatchesSingleSkipTarget); |
| } |
| |
| function accumulateEnterLeaveDispatches(leave, enter, fromID, toID) { |
| EventPluginHub.injection.getInstanceHandle().traverseEnterLeave(fromID, toID, accumulateDispatches, leave, enter); |
| } |
| |
| function accumulateDirectDispatches(events) { |
| forEachAccumulated(events, accumulateDirectDispatchesSingle); |
| } |
| |
| /** |
| * A small set of propagation patterns, each of which will accept a small amount |
| * of information, and generate a set of "dispatch ready event objects" - which |
| * are sets of events that have already been annotated with a set of dispatched |
| * listener functions/ids. The API is designed this way to discourage these |
| * propagation strategies from actually executing the dispatches, since we |
| * always want to collect the entire set of dispatches before executing event a |
| * single one. |
| * |
| * @constructor EventPropagators |
| */ |
| var EventPropagators = { |
| accumulateTwoPhaseDispatches: accumulateTwoPhaseDispatches, |
| accumulateTwoPhaseDispatchesSkipTarget: accumulateTwoPhaseDispatchesSkipTarget, |
| accumulateDirectDispatches: accumulateDirectDispatches, |
| accumulateEnterLeaveDispatches: accumulateEnterLeaveDispatches |
| }; |
| |
| module.exports = EventPropagators; |
| },{"115":115,"124":124,"15":15,"16":16,"173":173}],20:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule FallbackCompositionState |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var PooledClass = _dereq_(25); |
| |
| var assign = _dereq_(24); |
| var getTextContentAccessor = _dereq_(131); |
| |
| /** |
| * 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 |
| */ |
| function FallbackCompositionState(root) { |
| this._root = root; |
| this._startText = this.getText(); |
| this._fallbackText = null; |
| } |
| |
| assign(FallbackCompositionState.prototype, { |
| destructor: function () { |
| this._root = null; |
| this._startText = null; |
| this._fallbackText = null; |
| }, |
| |
| /** |
| * Get current text of input. |
| * |
| * @return {string} |
| */ |
| getText: function () { |
| if ('value' in this._root) { |
| return this._root.value; |
| } |
| return this._root[getTextContentAccessor()]; |
| }, |
| |
| /** |
| * Determine the differing substring between the initially stored |
| * text content and the current content. |
| * |
| * @return {string} |
| */ |
| getData: function () { |
| if (this._fallbackText) { |
| return this._fallbackText; |
| } |
| |
| var start; |
| var startValue = this._startText; |
| var startLength = startValue.length; |
| var end; |
| var endValue = this.getText(); |
| var endLength = endValue.length; |
| |
| for (start = 0; start < startLength; start++) { |
| if (startValue[start] !== endValue[start]) { |
| break; |
| } |
| } |
| |
| var minEnd = startLength - start; |
| for (end = 1; end <= minEnd; end++) { |
| if (startValue[startLength - end] !== endValue[endLength - end]) { |
| break; |
| } |
| } |
| |
| var sliceTail = end > 1 ? 1 - end : undefined; |
| this._fallbackText = endValue.slice(start, sliceTail); |
| return this._fallbackText; |
| } |
| }); |
| |
| PooledClass.addPoolingTo(FallbackCompositionState); |
| |
| module.exports = FallbackCompositionState; |
| },{"131":131,"24":24,"25":25}],21:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule HTMLDOMPropertyConfig |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE; |
| var MUST_USE_PROPERTY = DOMProperty.injection.MUST_USE_PROPERTY; |
| var HAS_BOOLEAN_VALUE = DOMProperty.injection.HAS_BOOLEAN_VALUE; |
| var HAS_SIDE_EFFECTS = DOMProperty.injection.HAS_SIDE_EFFECTS; |
| var HAS_NUMERIC_VALUE = DOMProperty.injection.HAS_NUMERIC_VALUE; |
| var HAS_POSITIVE_NUMERIC_VALUE = DOMProperty.injection.HAS_POSITIVE_NUMERIC_VALUE; |
| var HAS_OVERLOADED_BOOLEAN_VALUE = DOMProperty.injection.HAS_OVERLOADED_BOOLEAN_VALUE; |
| |
| var hasSVG; |
| if (ExecutionEnvironment.canUseDOM) { |
| var implementation = document.implementation; |
| hasSVG = implementation && implementation.hasFeature && implementation.hasFeature('http://www.w3.org/TR/SVG11/feature#BasicStructure', '1.1'); |
| } |
| |
| var HTMLDOMPropertyConfig = { |
| isCustomAttribute: RegExp.prototype.test.bind(/^(data|aria)-[a-z_][a-z\d_.\-]*$/), |
| Properties: { |
| /** |
| * Standard Properties |
| */ |
| accept: null, |
| acceptCharset: null, |
| accessKey: null, |
| action: null, |
| allowFullScreen: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| allowTransparency: MUST_USE_ATTRIBUTE, |
| alt: null, |
| async: HAS_BOOLEAN_VALUE, |
| autoComplete: null, |
| // autoFocus is polyfilled/normalized by AutoFocusUtils |
| // autoFocus: HAS_BOOLEAN_VALUE, |
| autoPlay: HAS_BOOLEAN_VALUE, |
| capture: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| cellPadding: null, |
| cellSpacing: null, |
| charSet: MUST_USE_ATTRIBUTE, |
| challenge: MUST_USE_ATTRIBUTE, |
| checked: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| classID: MUST_USE_ATTRIBUTE, |
| // To set className on SVG elements, it's necessary to use .setAttribute; |
| // this works on HTML elements too in all browsers except IE8. Conveniently, |
| // IE8 doesn't support SVG and so we can simply use the attribute in |
| // browsers that support SVG and the property in browsers that don't, |
| // regardless of whether the element is HTML or SVG. |
| className: hasSVG ? MUST_USE_ATTRIBUTE : MUST_USE_PROPERTY, |
| cols: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE, |
| colSpan: null, |
| content: null, |
| contentEditable: null, |
| contextMenu: MUST_USE_ATTRIBUTE, |
| controls: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| coords: null, |
| crossOrigin: null, |
| data: null, // For `<object />` acts as `src`. |
| dateTime: MUST_USE_ATTRIBUTE, |
| 'default': HAS_BOOLEAN_VALUE, |
| defer: HAS_BOOLEAN_VALUE, |
| dir: null, |
| disabled: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| download: HAS_OVERLOADED_BOOLEAN_VALUE, |
| draggable: null, |
| encType: null, |
| form: MUST_USE_ATTRIBUTE, |
| formAction: MUST_USE_ATTRIBUTE, |
| formEncType: MUST_USE_ATTRIBUTE, |
| formMethod: MUST_USE_ATTRIBUTE, |
| formNoValidate: HAS_BOOLEAN_VALUE, |
| formTarget: MUST_USE_ATTRIBUTE, |
| frameBorder: MUST_USE_ATTRIBUTE, |
| headers: null, |
| height: MUST_USE_ATTRIBUTE, |
| hidden: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| high: null, |
| href: null, |
| hrefLang: null, |
| htmlFor: null, |
| httpEquiv: null, |
| icon: null, |
| id: MUST_USE_PROPERTY, |
| inputMode: MUST_USE_ATTRIBUTE, |
| is: MUST_USE_ATTRIBUTE, |
| keyParams: MUST_USE_ATTRIBUTE, |
| keyType: MUST_USE_ATTRIBUTE, |
| kind: null, |
| label: null, |
| lang: null, |
| list: MUST_USE_ATTRIBUTE, |
| loop: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| low: null, |
| manifest: MUST_USE_ATTRIBUTE, |
| marginHeight: null, |
| marginWidth: null, |
| max: null, |
| maxLength: MUST_USE_ATTRIBUTE, |
| media: MUST_USE_ATTRIBUTE, |
| mediaGroup: null, |
| method: null, |
| min: null, |
| minLength: MUST_USE_ATTRIBUTE, |
| multiple: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| muted: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| name: null, |
| noValidate: HAS_BOOLEAN_VALUE, |
| open: HAS_BOOLEAN_VALUE, |
| optimum: null, |
| pattern: null, |
| placeholder: null, |
| poster: null, |
| preload: null, |
| radioGroup: null, |
| readOnly: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| rel: null, |
| required: HAS_BOOLEAN_VALUE, |
| role: MUST_USE_ATTRIBUTE, |
| rows: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE, |
| rowSpan: null, |
| sandbox: null, |
| scope: null, |
| scoped: HAS_BOOLEAN_VALUE, |
| scrolling: null, |
| seamless: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| selected: MUST_USE_PROPERTY | HAS_BOOLEAN_VALUE, |
| shape: null, |
| size: MUST_USE_ATTRIBUTE | HAS_POSITIVE_NUMERIC_VALUE, |
| sizes: MUST_USE_ATTRIBUTE, |
| span: HAS_POSITIVE_NUMERIC_VALUE, |
| spellCheck: null, |
| src: null, |
| srcDoc: MUST_USE_PROPERTY, |
| srcLang: null, |
| srcSet: MUST_USE_ATTRIBUTE, |
| start: HAS_NUMERIC_VALUE, |
| step: null, |
| style: null, |
| summary: null, |
| tabIndex: null, |
| target: null, |
| title: null, |
| type: null, |
| useMap: null, |
| value: MUST_USE_PROPERTY | HAS_SIDE_EFFECTS, |
| width: MUST_USE_ATTRIBUTE, |
| wmode: MUST_USE_ATTRIBUTE, |
| wrap: null, |
| |
| /** |
| * RDFa Properties |
| */ |
| about: MUST_USE_ATTRIBUTE, |
| datatype: MUST_USE_ATTRIBUTE, |
| inlist: MUST_USE_ATTRIBUTE, |
| prefix: MUST_USE_ATTRIBUTE, |
| // property is also supported for OpenGraph in meta tags. |
| property: MUST_USE_ATTRIBUTE, |
| resource: MUST_USE_ATTRIBUTE, |
| 'typeof': MUST_USE_ATTRIBUTE, |
| vocab: MUST_USE_ATTRIBUTE, |
| |
| /** |
| * Non-standard Properties |
| */ |
| // autoCapitalize and autoCorrect are supported in Mobile Safari for |
| // keyboard hints. |
| autoCapitalize: null, |
| autoCorrect: null, |
| // autoSave allows WebKit/Blink to persist values of input fields on page reloads |
| autoSave: null, |
| // color is for Safari mask-icon link |
| color: null, |
| // itemProp, itemScope, itemType are for |
| // Microdata support. See http://schema.org/docs/gs.html |
| itemProp: MUST_USE_ATTRIBUTE, |
| itemScope: MUST_USE_ATTRIBUTE | HAS_BOOLEAN_VALUE, |
| itemType: MUST_USE_ATTRIBUTE, |
| // itemID and itemRef are for Microdata support as well but |
| // only specified in the the WHATWG spec document. See |
| // https://html.spec.whatwg.org/multipage/microdata.html#microdata-dom-api |
| itemID: MUST_USE_ATTRIBUTE, |
| itemRef: MUST_USE_ATTRIBUTE, |
| // results show looking glass icon and recent searches on input |
| // search fields in WebKit/Blink |
| results: null, |
| // IE-only attribute that specifies security restrictions on an iframe |
| // as an alternative to the sandbox attribute on IE<10 |
| security: MUST_USE_ATTRIBUTE, |
| // IE-only attribute that controls focus behavior |
| unselectable: MUST_USE_ATTRIBUTE |
| }, |
| DOMAttributeNames: { |
| acceptCharset: 'accept-charset', |
| className: 'class', |
| htmlFor: 'for', |
| httpEquiv: 'http-equiv' |
| }, |
| DOMPropertyNames: { |
| autoCapitalize: 'autocapitalize', |
| autoComplete: 'autocomplete', |
| autoCorrect: 'autocorrect', |
| autoFocus: 'autofocus', |
| autoPlay: 'autoplay', |
| autoSave: 'autosave', |
| // `encoding` is equivalent to `enctype`, IE8 lacks an `enctype` setter. |
| // http://www.w3.org/TR/html5/forms.html#dom-fs-encoding |
| encType: 'encoding', |
| hrefLang: 'hreflang', |
| radioGroup: 'radiogroup', |
| spellCheck: 'spellcheck', |
| srcDoc: 'srcdoc', |
| srcSet: 'srcset' |
| } |
| }; |
| |
| module.exports = HTMLDOMPropertyConfig; |
| },{"10":10,"147":147}],22:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule LinkedStateMixin |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactLink = _dereq_(70); |
| var ReactStateSetters = _dereq_(90); |
| |
| /** |
| * A simple mixin around ReactLink.forState(). |
| */ |
| var LinkedStateMixin = { |
| /** |
| * Create a ReactLink that's linked to part of this component's state. The |
| * ReactLink will have the current value of this.state[key] and will call |
| * setState() when a change is requested. |
| * |
| * @param {string} key state key to update. Note: you may want to use keyOf() |
| * if you're using Google Closure Compiler advanced mode. |
| * @return {ReactLink} ReactLink instance linking to the state. |
| */ |
| linkState: function (key) { |
| return new ReactLink(this.state[key], ReactStateSetters.createStateKeySetter(this, key)); |
| } |
| }; |
| |
| module.exports = LinkedStateMixin; |
| },{"70":70,"90":90}],23:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule LinkedValueUtils |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactPropTypes = _dereq_(82); |
| var ReactPropTypeLocations = _dereq_(81); |
| |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| var hasReadOnlyValue = { |
| 'button': true, |
| 'checkbox': true, |
| 'image': true, |
| 'hidden': true, |
| 'radio': true, |
| 'reset': true, |
| 'submit': true |
| }; |
| |
| function _assertSingleLink(inputProps) { |
| !(inputProps.checkedLink == null || inputProps.valueLink == null) ? "development" !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a valueLink. If you want to use ' + 'checkedLink, you probably don\'t want to use valueLink and vice versa.') : invariant(false) : undefined; |
| } |
| function _assertValueLink(inputProps) { |
| _assertSingleLink(inputProps); |
| !(inputProps.value == null && inputProps.onChange == null) ? "development" !== 'production' ? invariant(false, 'Cannot provide a valueLink and a value or onChange event. If you want ' + 'to use value or onChange, you probably don\'t want to use valueLink.') : invariant(false) : undefined; |
| } |
| |
| function _assertCheckedLink(inputProps) { |
| _assertSingleLink(inputProps); |
| !(inputProps.checked == null && inputProps.onChange == null) ? "development" !== 'production' ? invariant(false, 'Cannot provide a checkedLink and a checked property or onChange event. ' + 'If you want to use checked or onChange, you probably don\'t want to ' + 'use checkedLink') : invariant(false) : undefined; |
| } |
| |
| var propTypes = { |
| value: function (props, propName, componentName) { |
| if (!props[propName] || hasReadOnlyValue[props.type] || props.onChange || props.readOnly || props.disabled) { |
| return null; |
| } |
| return new Error('You provided a `value` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultValue`. Otherwise, ' + 'set either `onChange` or `readOnly`.'); |
| }, |
| checked: function (props, propName, componentName) { |
| if (!props[propName] || props.onChange || props.readOnly || props.disabled) { |
| return null; |
| } |
| return new Error('You provided a `checked` prop to a form field without an ' + '`onChange` handler. This will render a read-only field. If ' + 'the field should be mutable use `defaultChecked`. Otherwise, ' + 'set either `onChange` or `readOnly`.'); |
| }, |
| onChange: ReactPropTypes.func |
| }; |
| |
| var loggedTypeFailures = {}; |
| function getDeclarationErrorAddendum(owner) { |
| if (owner) { |
| var name = owner.getName(); |
| if (name) { |
| return ' Check the render method of `' + name + '`.'; |
| } |
| } |
| return ''; |
| } |
| |
| /** |
| * Provide a linked `value` attribute for controlled forms. You should not use |
| * this outside of the ReactDOM controlled form components. |
| */ |
| var LinkedValueUtils = { |
| checkPropTypes: function (tagName, props, owner) { |
| for (var propName in propTypes) { |
| if (propTypes.hasOwnProperty(propName)) { |
| var error = propTypes[propName](props, propName, tagName, ReactPropTypeLocations.prop); |
| } |
| if (error instanceof Error && !(error.message in loggedTypeFailures)) { |
| // Only monitor this failure once because there tends to be a lot of the |
| // same error. |
| loggedTypeFailures[error.message] = true; |
| |
| var addendum = getDeclarationErrorAddendum(owner); |
| "development" !== 'production' ? warning(false, 'Failed form propType: %s%s', error.message, addendum) : undefined; |
| } |
| } |
| }, |
| |
| /** |
| * @param {object} inputProps Props for form component |
| * @return {*} current value of the input either from value prop or link. |
| */ |
| getValue: function (inputProps) { |
| if (inputProps.valueLink) { |
| _assertValueLink(inputProps); |
| return inputProps.valueLink.value; |
| } |
| return inputProps.value; |
| }, |
| |
| /** |
| * @param {object} inputProps Props for form component |
| * @return {*} current checked status of the input either from checked prop |
| * or link. |
| */ |
| getChecked: function (inputProps) { |
| if (inputProps.checkedLink) { |
| _assertCheckedLink(inputProps); |
| return inputProps.checkedLink.value; |
| } |
| return inputProps.checked; |
| }, |
| |
| /** |
| * @param {object} inputProps Props for form component |
| * @param {SyntheticEvent} event change event to handle |
| */ |
| executeOnChange: function (inputProps, event) { |
| if (inputProps.valueLink) { |
| _assertValueLink(inputProps); |
| return inputProps.valueLink.requestChange(event.target.value); |
| } else if (inputProps.checkedLink) { |
| _assertCheckedLink(inputProps); |
| return inputProps.checkedLink.requestChange(event.target.checked); |
| } else if (inputProps.onChange) { |
| return inputProps.onChange.call(undefined, event); |
| } |
| } |
| }; |
| |
| module.exports = LinkedValueUtils; |
| },{"161":161,"173":173,"81":81,"82":82}],24:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule Object.assign |
| */ |
| |
| // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign |
| |
| 'use strict'; |
| |
| function assign(target, sources) { |
| if (target == null) { |
| throw new TypeError('Object.assign target cannot be null or undefined'); |
| } |
| |
| var to = Object(target); |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| |
| for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) { |
| var nextSource = arguments[nextIndex]; |
| if (nextSource == null) { |
| continue; |
| } |
| |
| var from = Object(nextSource); |
| |
| // We don't currently support accessors nor proxies. Therefore this |
| // copy cannot throw. If we ever supported this then we must handle |
| // exceptions and side-effects. We don't support symbols so they won't |
| // be transferred. |
| |
| for (var key in from) { |
| if (hasOwnProperty.call(from, key)) { |
| to[key] = from[key]; |
| } |
| } |
| } |
| |
| return to; |
| } |
| |
| module.exports = assign; |
| },{}],25:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule PooledClass |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Static poolers. Several custom versions for each potential number of |
| * arguments. A completely generic pooler is easy to implement, but would |
| * require accessing the `arguments` object. In each of these, `this` refers to |
| * the Class itself, not an instance. If any others are needed, simply add them |
| * here, or in their own files. |
| */ |
| var oneArgumentPooler = function (copyFieldsFrom) { |
| var Klass = this; |
| if (Klass.instancePool.length) { |
| var instance = Klass.instancePool.pop(); |
| Klass.call(instance, copyFieldsFrom); |
| return instance; |
| } else { |
| return new Klass(copyFieldsFrom); |
| } |
| }; |
| |
| var twoArgumentPooler = function (a1, a2) { |
| var Klass = this; |
| if (Klass.instancePool.length) { |
| var instance = Klass.instancePool.pop(); |
| Klass.call(instance, a1, a2); |
| return instance; |
| } else { |
| return new Klass(a1, a2); |
| } |
| }; |
| |
| var threeArgumentPooler = function (a1, a2, a3) { |
| var Klass = this; |
| if (Klass.instancePool.length) { |
| var instance = Klass.instancePool.pop(); |
| Klass.call(instance, a1, a2, a3); |
| return instance; |
| } else { |
| return new Klass(a1, a2, a3); |
| } |
| }; |
| |
| var fourArgumentPooler = function (a1, a2, a3, a4) { |
| var Klass = this; |
| if (Klass.instancePool.length) { |
| var instance = Klass.instancePool.pop(); |
| Klass.call(instance, a1, a2, a3, a4); |
| return instance; |
| } else { |
| return new Klass(a1, a2, a3, a4); |
| } |
| }; |
| |
| var fiveArgumentPooler = function (a1, a2, a3, a4, a5) { |
| var Klass = this; |
| if (Klass.instancePool.length) { |
| var instance = Klass.instancePool.pop(); |
| Klass.call(instance, a1, a2, a3, a4, a5); |
| return instance; |
| } else { |
| return new Klass(a1, a2, a3, a4, a5); |
| } |
| }; |
| |
| var standardReleaser = function (instance) { |
| var Klass = this; |
| !(instance instanceof Klass) ? "development" !== 'production' ? invariant(false, 'Trying to release an instance into a pool of a different type.') : invariant(false) : undefined; |
| instance.destructor(); |
| if (Klass.instancePool.length < Klass.poolSize) { |
| Klass.instancePool.push(instance); |
| } |
| }; |
| |
| var DEFAULT_POOL_SIZE = 10; |
| var DEFAULT_POOLER = oneArgumentPooler; |
| |
| /** |
| * Augments `CopyConstructor` to be a poolable class, augmenting only the class |
| * itself (statically) not adding any prototypical fields. Any CopyConstructor |
| * you give this may have a `poolSize` property, and will look for a |
| * prototypical `destructor` on instances (optional). |
| * |
| * @param {Function} CopyConstructor Constructor that can be used to reset. |
| * @param {Function} pooler Customizable pooler. |
| */ |
| var addPoolingTo = function (CopyConstructor, pooler) { |
| var NewKlass = CopyConstructor; |
| NewKlass.instancePool = []; |
| NewKlass.getPooled = pooler || DEFAULT_POOLER; |
| if (!NewKlass.poolSize) { |
| NewKlass.poolSize = DEFAULT_POOL_SIZE; |
| } |
| NewKlass.release = standardReleaser; |
| return NewKlass; |
| }; |
| |
| var PooledClass = { |
| addPoolingTo: addPoolingTo, |
| oneArgumentPooler: oneArgumentPooler, |
| twoArgumentPooler: twoArgumentPooler, |
| threeArgumentPooler: threeArgumentPooler, |
| fourArgumentPooler: fourArgumentPooler, |
| fiveArgumentPooler: fiveArgumentPooler |
| }; |
| |
| module.exports = PooledClass; |
| },{"161":161}],26:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule React |
| */ |
| |
| 'use strict'; |
| |
| var ReactDOM = _dereq_(40); |
| var ReactDOMServer = _dereq_(50); |
| var ReactIsomorphic = _dereq_(69); |
| |
| var assign = _dereq_(24); |
| var deprecated = _dereq_(120); |
| |
| // `version` will be added here by ReactIsomorphic. |
| var React = {}; |
| |
| assign(React, ReactIsomorphic); |
| |
| assign(React, { |
| // ReactDOM |
| findDOMNode: deprecated('findDOMNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.findDOMNode), |
| render: deprecated('render', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.render), |
| unmountComponentAtNode: deprecated('unmountComponentAtNode', 'ReactDOM', 'react-dom', ReactDOM, ReactDOM.unmountComponentAtNode), |
| |
| // ReactDOMServer |
| renderToString: deprecated('renderToString', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToString), |
| renderToStaticMarkup: deprecated('renderToStaticMarkup', 'ReactDOMServer', 'react-dom/server', ReactDOMServer, ReactDOMServer.renderToStaticMarkup) |
| }); |
| |
| React.__SECRET_DOM_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = ReactDOM; |
| |
| module.exports = React; |
| },{"120":120,"24":24,"40":40,"50":50,"69":69}],27:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactBrowserComponentMixin |
| */ |
| |
| 'use strict'; |
| |
| var ReactInstanceMap = _dereq_(68); |
| |
| var findDOMNode = _dereq_(122); |
| var warning = _dereq_(173); |
| |
| var didWarnKey = '_getDOMNodeDidWarn'; |
| |
| var ReactBrowserComponentMixin = { |
| /** |
| * Returns the DOM node rendered by this component. |
| * |
| * @return {DOMElement} The root node of this component. |
| * @final |
| * @protected |
| */ |
| getDOMNode: function () { |
| "development" !== 'production' ? warning(this.constructor[didWarnKey], '%s.getDOMNode(...) is deprecated. Please use ' + 'ReactDOM.findDOMNode(instance) instead.', ReactInstanceMap.get(this).getName() || this.tagName || 'Unknown') : undefined; |
| this.constructor[didWarnKey] = true; |
| return findDOMNode(this); |
| } |
| }; |
| |
| module.exports = ReactBrowserComponentMixin; |
| },{"122":122,"173":173,"68":68}],28:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactBrowserEventEmitter |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPluginHub = _dereq_(16); |
| var EventPluginRegistry = _dereq_(17); |
| var ReactEventEmitterMixin = _dereq_(62); |
| var ReactPerf = _dereq_(78); |
| var ViewportMetrics = _dereq_(114); |
| |
| var assign = _dereq_(24); |
| var isEventSupported = _dereq_(133); |
| |
| /** |
| * Summary of `ReactBrowserEventEmitter` event handling: |
| * |
| * - Top-level delegation is used to trap most native browser events. This |
| * may only occur in the main thread and is the responsibility of |
| * ReactEventListener, which is injected and can therefore support pluggable |
| * event sources. This is the only work that occurs in the main thread. |
| * |
| * - We normalize and de-duplicate events to account for browser quirks. This |
| * may be done in the worker thread. |
| * |
| * - Forward these native events (with the associated top-level type used to |
| * trap it) to `EventPluginHub`, which in turn will ask plugins if they want |
| * to extract any synthetic events. |
| * |
| * - The `EventPluginHub` will then process each event by annotating them with |
| * "dispatches", a sequence of listeners and IDs that care about that event. |
| * |
| * - The `EventPluginHub` then dispatches the events. |
| * |
| * Overview of React and the event system: |
| * |
| * +------------+ . |
| * | DOM | . |
| * +------------+ . |
| * | . |
| * v . |
| * +------------+ . |
| * | ReactEvent | . |
| * | Listener | . |
| * +------------+ . +-----------+ |
| * | . +--------+|SimpleEvent| |
| * | . | |Plugin | |
| * +-----|------+ . v +-----------+ |
| * | | | . +--------------+ +------------+ |
| * | +-----------.--->|EventPluginHub| | Event | |
| * | | . | | +-----------+ | Propagators| |
| * | ReactEvent | . | | |TapEvent | |------------| |
| * | Emitter | . | |<---+|Plugin | |other plugin| |
| * | | . | | +-----------+ | utilities | |
| * | +-----------.--->| | +------------+ |
| * | | | . +--------------+ |
| * +-----|------+ . ^ +-----------+ |
| * | . | |Enter/Leave| |
| * + . +-------+|Plugin | |
| * +-------------+ . +-----------+ |
| * | application | . |
| * |-------------| . |
| * | | . |
| * | | . |
| * +-------------+ . |
| * . |
| * React Core . General Purpose Event Plugin System |
| */ |
| |
| var alreadyListeningTo = {}; |
| var isMonitoringScrollValue = false; |
| var reactTopListenersCounter = 0; |
| |
| // For events like 'submit' which don't consistently bubble (which we trap at a |
| // lower node than `document`), binding at `document` would cause duplicate |
| // events so we don't include them here |
| var topEventMapping = { |
| topAbort: 'abort', |
| topBlur: 'blur', |
| topCanPlay: 'canplay', |
| topCanPlayThrough: 'canplaythrough', |
| topChange: 'change', |
| topClick: 'click', |
| topCompositionEnd: 'compositionend', |
| topCompositionStart: 'compositionstart', |
| topCompositionUpdate: 'compositionupdate', |
| topContextMenu: 'contextmenu', |
| topCopy: 'copy', |
| topCut: 'cut', |
| topDoubleClick: 'dblclick', |
| topDrag: 'drag', |
| topDragEnd: 'dragend', |
| topDragEnter: 'dragenter', |
| topDragExit: 'dragexit', |
| topDragLeave: 'dragleave', |
| topDragOver: 'dragover', |
| topDragStart: 'dragstart', |
| topDrop: 'drop', |
| topDurationChange: 'durationchange', |
| topEmptied: 'emptied', |
| topEncrypted: 'encrypted', |
| topEnded: 'ended', |
| topError: 'error', |
| topFocus: 'focus', |
| topInput: 'input', |
| topKeyDown: 'keydown', |
| topKeyPress: 'keypress', |
| topKeyUp: 'keyup', |
| topLoadedData: 'loadeddata', |
| topLoadedMetadata: 'loadedmetadata', |
| topLoadStart: 'loadstart', |
| topMouseDown: 'mousedown', |
| topMouseMove: 'mousemove', |
| topMouseOut: 'mouseout', |
| topMouseOver: 'mouseover', |
| topMouseUp: 'mouseup', |
| topPaste: 'paste', |
| topPause: 'pause', |
| topPlay: 'play', |
| topPlaying: 'playing', |
| topProgress: 'progress', |
| topRateChange: 'ratechange', |
| topScroll: 'scroll', |
| topSeeked: 'seeked', |
| topSeeking: 'seeking', |
| topSelectionChange: 'selectionchange', |
| topStalled: 'stalled', |
| topSuspend: 'suspend', |
| topTextInput: 'textInput', |
| topTimeUpdate: 'timeupdate', |
| topTouchCancel: 'touchcancel', |
| topTouchEnd: 'touchend', |
| topTouchMove: 'touchmove', |
| topTouchStart: 'touchstart', |
| topVolumeChange: 'volumechange', |
| topWaiting: 'waiting', |
| topWheel: 'wheel' |
| }; |
| |
| /** |
| * To ensure no conflicts with other potential React instances on the page |
| */ |
| var topListenersIDKey = '_reactListenersID' + String(Math.random()).slice(2); |
| |
| 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]]; |
| } |
| |
| /** |
| * `ReactBrowserEventEmitter` is used to attach top-level event listeners. For |
| * example: |
| * |
| * ReactBrowserEventEmitter.putListener('myID', 'onClick', myFunction); |
| * |
| * This would allocate a "registration" of `('onClick', myFunction)` on 'myID'. |
| * |
| * @internal |
| */ |
| var ReactBrowserEventEmitter = assign({}, ReactEventEmitterMixin, { |
| |
| /** |
| * Injectable event backend |
| */ |
| ReactEventListener: null, |
| |
| injection: { |
| /** |
| * @param {object} ReactEventListener |
| */ |
| injectReactEventListener: function (ReactEventListener) { |
| ReactEventListener.setHandleTopLevel(ReactBrowserEventEmitter.handleTopLevel); |
| ReactBrowserEventEmitter.ReactEventListener = ReactEventListener; |
| } |
| }, |
| |
| /** |
| * Sets whether or not any created callbacks should be enabled. |
| * |
| * @param {boolean} enabled True if callbacks should be enabled. |
| */ |
| setEnabled: function (enabled) { |
| if (ReactBrowserEventEmitter.ReactEventListener) { |
| ReactBrowserEventEmitter.ReactEventListener.setEnabled(enabled); |
| } |
| }, |
| |
| /** |
| * @return {boolean} True if callbacks are enabled. |
| */ |
| isEnabled: function () { |
| return !!(ReactBrowserEventEmitter.ReactEventListener && ReactBrowserEventEmitter.ReactEventListener.isEnabled()); |
| }, |
| |
| /** |
| * We listen for bubbled touch events on the document object. |
| * |
| * Firefox v8.01 (and possibly others) exhibited strange behavior when |
| * mounting `onmousemove` events at some node that was not the document |
| * element. The symptoms were that if your mouse is not moving over something |
| * contained within that mount point (for example on the background) the |
| * top-level listeners for `onmousemove` won't be called. However, if you |
| * register the `mousemove` on the document object, then it will of course |
| * catch all `mousemove`s. This along with iOS quirks, justifies restricting |
| * top-level listeners to the document object only, at least for these |
| * movement types of events and possibly all events. |
| * |
| * @see http://www.quirksmode.org/blog/archives/2010/09/click_event_del.html |
| * |
| * Also, `keyup`/`keypress`/`keydown` do not bubble to the window on IE, but |
| * they bubble to document. |
| * |
| * @param {string} registrationName Name of listener (e.g. `onClick`). |
| * @param {object} contentDocumentHandle Document which owns the container |
| */ |
| listenTo: function (registrationName, contentDocumentHandle) { |
| var mountAt = contentDocumentHandle; |
| var isListening = getListeningForDocument(mountAt); |
| var dependencies = EventPluginRegistry.registrationNameDependencies[registrationName]; |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| for (var i = 0; i < dependencies.length; i++) { |
| var dependency = dependencies[i]; |
| if (!(isListening.hasOwnProperty(dependency) && isListening[dependency])) { |
| if (dependency === topLevelTypes.topWheel) { |
| if (isEventSupported('wheel')) { |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'wheel', mountAt); |
| } else if (isEventSupported('mousewheel')) { |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'mousewheel', mountAt); |
| } else { |
| // Firefox needs to capture a different mouse scroll event. |
| // @see http://www.quirksmode.org/dom/events/tests/scroll.html |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topWheel, 'DOMMouseScroll', mountAt); |
| } |
| } else if (dependency === topLevelTypes.topScroll) { |
| |
| if (isEventSupported('scroll', true)) { |
| ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topScroll, 'scroll', mountAt); |
| } else { |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topScroll, 'scroll', ReactBrowserEventEmitter.ReactEventListener.WINDOW_HANDLE); |
| } |
| } else if (dependency === topLevelTypes.topFocus || dependency === topLevelTypes.topBlur) { |
| |
| if (isEventSupported('focus', true)) { |
| ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topFocus, 'focus', mountAt); |
| ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelTypes.topBlur, 'blur', mountAt); |
| } else if (isEventSupported('focusin')) { |
| // IE has `focusin` and `focusout` events which bubble. |
| // @see http://www.quirksmode.org/blog/archives/2008/04/delegating_the.html |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topFocus, 'focusin', mountAt); |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelTypes.topBlur, 'focusout', mountAt); |
| } |
| |
| // to make sure blur and focus event listeners are only attached once |
| isListening[topLevelTypes.topBlur] = true; |
| isListening[topLevelTypes.topFocus] = true; |
| } else if (topEventMapping.hasOwnProperty(dependency)) { |
| ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(dependency, topEventMapping[dependency], mountAt); |
| } |
| |
| isListening[dependency] = true; |
| } |
| } |
| }, |
| |
| trapBubbledEvent: function (topLevelType, handlerBaseName, handle) { |
| return ReactBrowserEventEmitter.ReactEventListener.trapBubbledEvent(topLevelType, handlerBaseName, handle); |
| }, |
| |
| trapCapturedEvent: function (topLevelType, handlerBaseName, handle) { |
| return ReactBrowserEventEmitter.ReactEventListener.trapCapturedEvent(topLevelType, handlerBaseName, handle); |
| }, |
| |
| /** |
| * Listens to window scroll and resize events. We cache scroll values so that |
| * application code can access them without triggering reflows. |
| * |
| * NOTE: Scroll events do not bubble. |
| * |
| * @see http://www.quirksmode.org/dom/events/scroll.html |
| */ |
| ensureScrollValueMonitoring: function () { |
| if (!isMonitoringScrollValue) { |
| var refresh = ViewportMetrics.refreshScrollValues; |
| ReactBrowserEventEmitter.ReactEventListener.monitorScrollValue(refresh); |
| isMonitoringScrollValue = true; |
| } |
| }, |
| |
| eventNameDispatchConfigs: EventPluginHub.eventNameDispatchConfigs, |
| |
| registrationNameModules: EventPluginHub.registrationNameModules, |
| |
| putListener: EventPluginHub.putListener, |
| |
| getListener: EventPluginHub.getListener, |
| |
| deleteListener: EventPluginHub.deleteListener, |
| |
| deleteAllListeners: EventPluginHub.deleteAllListeners |
| |
| }); |
| |
| ReactPerf.measureMethods(ReactBrowserEventEmitter, 'ReactBrowserEventEmitter', { |
| putListener: 'putListener', |
| deleteListener: 'deleteListener' |
| }); |
| |
| module.exports = ReactBrowserEventEmitter; |
| },{"114":114,"133":133,"15":15,"16":16,"17":17,"24":24,"62":62,"78":78}],29:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @typechecks |
| * @providesModule ReactCSSTransitionGroup |
| */ |
| |
| 'use strict'; |
| |
| var React = _dereq_(26); |
| |
| var assign = _dereq_(24); |
| |
| var ReactTransitionGroup = _dereq_(94); |
| var ReactCSSTransitionGroupChild = _dereq_(30); |
| |
| function createTransitionTimeoutPropValidator(transitionType) { |
| var timeoutPropName = 'transition' + transitionType + 'Timeout'; |
| var enabledPropName = 'transition' + transitionType; |
| |
| return function (props) { |
| // If the transition is enabled |
| if (props[enabledPropName]) { |
| // If no timeout duration is provided |
| if (props[timeoutPropName] == null) { |
| return new Error(timeoutPropName + ' wasn\'t supplied to ReactCSSTransitionGroup: ' + 'this can cause unreliable animations and won\'t be supported in ' + 'a future version of React. See ' + 'https://fb.me/react-animation-transition-group-timeout for more ' + 'information.'); |
| |
| // If the duration isn't a number |
| } else if (typeof props[timeoutPropName] !== 'number') { |
| return new Error(timeoutPropName + ' must be a number (in milliseconds)'); |
| } |
| } |
| }; |
| } |
| |
| var ReactCSSTransitionGroup = React.createClass({ |
| displayName: 'ReactCSSTransitionGroup', |
| |
| propTypes: { |
| transitionName: ReactCSSTransitionGroupChild.propTypes.name, |
| |
| transitionAppear: React.PropTypes.bool, |
| transitionEnter: React.PropTypes.bool, |
| transitionLeave: React.PropTypes.bool, |
| transitionAppearTimeout: createTransitionTimeoutPropValidator('Appear'), |
| transitionEnterTimeout: createTransitionTimeoutPropValidator('Enter'), |
| transitionLeaveTimeout: createTransitionTimeoutPropValidator('Leave') |
| }, |
| |
| getDefaultProps: function () { |
| return { |
| transitionAppear: false, |
| transitionEnter: true, |
| transitionLeave: true |
| }; |
| }, |
| |
| _wrapChild: function (child) { |
| // We need to provide this childFactory so that |
| // ReactCSSTransitionGroupChild can receive updates to name, enter, and |
| // leave while it is leaving. |
| return React.createElement(ReactCSSTransitionGroupChild, { |
| name: this.props.transitionName, |
| appear: this.props.transitionAppear, |
| enter: this.props.transitionEnter, |
| leave: this.props.transitionLeave, |
| appearTimeout: this.props.transitionAppearTimeout, |
| enterTimeout: this.props.transitionEnterTimeout, |
| leaveTimeout: this.props.transitionLeaveTimeout |
| }, child); |
| }, |
| |
| render: function () { |
| return React.createElement(ReactTransitionGroup, assign({}, this.props, { childFactory: this._wrapChild })); |
| } |
| }); |
| |
| module.exports = ReactCSSTransitionGroup; |
| },{"24":24,"26":26,"30":30,"94":94}],30:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @typechecks |
| * @providesModule ReactCSSTransitionGroupChild |
| */ |
| |
| 'use strict'; |
| |
| var React = _dereq_(26); |
| var ReactDOM = _dereq_(40); |
| |
| var CSSCore = _dereq_(145); |
| var ReactTransitionEvents = _dereq_(93); |
| |
| var onlyChild = _dereq_(135); |
| |
| // We don't remove the element from the DOM until we receive an animationend or |
| // transitionend event. If the user screws up and forgets to add an animation |
| // their node will be stuck in the DOM forever, so we detect if an animation |
| // does not start and if it doesn't, we just call the end listener immediately. |
| var TICK = 17; |
| |
| var ReactCSSTransitionGroupChild = React.createClass({ |
| displayName: 'ReactCSSTransitionGroupChild', |
| |
| propTypes: { |
| name: React.PropTypes.oneOfType([React.PropTypes.string, React.PropTypes.shape({ |
| enter: React.PropTypes.string, |
| leave: React.PropTypes.string, |
| active: React.PropTypes.string |
| }), React.PropTypes.shape({ |
| enter: React.PropTypes.string, |
| enterActive: React.PropTypes.string, |
| leave: React.PropTypes.string, |
| leaveActive: React.PropTypes.string, |
| appear: React.PropTypes.string, |
| appearActive: React.PropTypes.string |
| })]).isRequired, |
| |
| // Once we require timeouts to be specified, we can remove the |
| // boolean flags (appear etc.) and just accept a number |
| // or a bool for the timeout flags (appearTimeout etc.) |
| appear: React.PropTypes.bool, |
| enter: React.PropTypes.bool, |
| leave: React.PropTypes.bool, |
| appearTimeout: React.PropTypes.number, |
| enterTimeout: React.PropTypes.number, |
| leaveTimeout: React.PropTypes.number |
| }, |
| |
| transition: function (animationType, finishCallback, userSpecifiedDelay) { |
| var node = ReactDOM.findDOMNode(this); |
| |
| if (!node) { |
| if (finishCallback) { |
| finishCallback(); |
| } |
| return; |
| } |
| |
| var className = this.props.name[animationType] || this.props.name + '-' + animationType; |
| var activeClassName = this.props.name[animationType + 'Active'] || className + '-active'; |
| var timeout = null; |
| |
| var endListener = function (e) { |
| if (e && e.target !== node) { |
| return; |
| } |
| |
| clearTimeout(timeout); |
| |
| CSSCore.removeClass(node, className); |
| CSSCore.removeClass(node, activeClassName); |
| |
| ReactTransitionEvents.removeEndEventListener(node, endListener); |
| |
| // Usually this optional callback is used for informing an owner of |
| // a leave animation and telling it to remove the child. |
| if (finishCallback) { |
| finishCallback(); |
| } |
| }; |
| |
| CSSCore.addClass(node, className); |
| |
| // Need to do this to actually trigger a transition. |
| this.queueClass(activeClassName); |
| |
| // If the user specified a timeout delay. |
| if (userSpecifiedDelay) { |
| // Clean-up the animation after the specified delay |
| timeout = setTimeout(endListener, userSpecifiedDelay); |
| } else { |
| // DEPRECATED: this listener will be removed in a future version of react |
| ReactTransitionEvents.addEndEventListener(node, endListener); |
| } |
| }, |
| |
| queueClass: function (className) { |
| this.classNameQueue.push(className); |
| |
| if (!this.timeout) { |
| this.timeout = setTimeout(this.flushClassNameQueue, TICK); |
| } |
| }, |
| |
| flushClassNameQueue: function () { |
| if (this.isMounted()) { |
| this.classNameQueue.forEach(CSSCore.addClass.bind(CSSCore, ReactDOM.findDOMNode(this))); |
| } |
| this.classNameQueue.length = 0; |
| this.timeout = null; |
| }, |
| |
| componentWillMount: function () { |
| this.classNameQueue = []; |
| }, |
| |
| componentWillUnmount: function () { |
| if (this.timeout) { |
| clearTimeout(this.timeout); |
| } |
| }, |
| |
| componentWillAppear: function (done) { |
| if (this.props.appear) { |
| this.transition('appear', done, this.props.appearTimeout); |
| } else { |
| done(); |
| } |
| }, |
| |
| componentWillEnter: function (done) { |
| if (this.props.enter) { |
| this.transition('enter', done, this.props.enterTimeout); |
| } else { |
| done(); |
| } |
| }, |
| |
| componentWillLeave: function (done) { |
| if (this.props.leave) { |
| this.transition('leave', done, this.props.leaveTimeout); |
| } else { |
| done(); |
| } |
| }, |
| |
| render: function () { |
| return onlyChild(this.props.children); |
| } |
| }); |
| |
| module.exports = ReactCSSTransitionGroupChild; |
| },{"135":135,"145":145,"26":26,"40":40,"93":93}],31:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactChildReconciler |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactReconciler = _dereq_(84); |
| |
| var instantiateReactComponent = _dereq_(132); |
| var shouldUpdateReactComponent = _dereq_(141); |
| var traverseAllChildren = _dereq_(142); |
| var warning = _dereq_(173); |
| |
| function instantiateChild(childInstances, child, name) { |
| // We found a component instance. |
| var keyUnique = childInstances[name] === undefined; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(keyUnique, '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.', name) : undefined; |
| } |
| if (child != null && keyUnique) { |
| childInstances[name] = instantiateReactComponent(child, null); |
| } |
| } |
| |
| /** |
| * ReactChildReconciler provides helpers for initializing or updating a set of |
| * children. Its output is suitable for passing it onto ReactMultiChild which |
| * does diffed reordering and insertion. |
| */ |
| var ReactChildReconciler = { |
| /** |
| * Generates a "mount image" for each of the supplied children. In the case |
| * of `ReactDOMComponent`, a mount image is a string of markup. |
| * |
| * @param {?object} nestedChildNodes Nested child maps. |
| * @return {?object} A set of child instances. |
| * @internal |
| */ |
| instantiateChildren: function (nestedChildNodes, transaction, context) { |
| if (nestedChildNodes == null) { |
| return null; |
| } |
| var childInstances = {}; |
| traverseAllChildren(nestedChildNodes, instantiateChild, childInstances); |
| return childInstances; |
| }, |
| |
| /** |
| * Updates the rendered children and returns a new set of children. |
| * |
| * @param {?object} prevChildren Previously initialized set of children. |
| * @param {?object} nextChildren Flat child element maps. |
| * @param {ReactReconcileTransaction} transaction |
| * @param {object} context |
| * @return {?object} A new set of child instances. |
| * @internal |
| */ |
| updateChildren: function (prevChildren, nextChildren, transaction, context) { |
| // We currently don't have a way to track moves here but if we use iterators |
| // instead of for..in we can zip the iterators and check if an item has |
| // moved. |
| // TODO: If nothing has changed, return the prevChildren object so that we |
| // can quickly bailout if nothing has changed. |
| if (!nextChildren && !prevChildren) { |
| return null; |
| } |
| var name; |
| for (name in nextChildren) { |
| if (!nextChildren.hasOwnProperty(name)) { |
| continue; |
| } |
| var prevChild = prevChildren && prevChildren[name]; |
| var prevElement = prevChild && prevChild._currentElement; |
| var nextElement = nextChildren[name]; |
| if (prevChild != null && shouldUpdateReactComponent(prevElement, nextElement)) { |
| ReactReconciler.receiveComponent(prevChild, nextElement, transaction, context); |
| nextChildren[name] = prevChild; |
| } else { |
| if (prevChild) { |
| ReactReconciler.unmountComponent(prevChild, name); |
| } |
| // The child must be instantiated before it's mounted. |
| var nextChildInstance = instantiateReactComponent(nextElement, null); |
| nextChildren[name] = nextChildInstance; |
| } |
| } |
| // Unmount children that are no longer present. |
| for (name in prevChildren) { |
| if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) { |
| ReactReconciler.unmountComponent(prevChildren[name]); |
| } |
| } |
| return nextChildren; |
| }, |
| |
| /** |
| * Unmounts all rendered children. This should be used to clean up children |
| * when this component is unmounted. |
| * |
| * @param {?object} renderedChildren Previously initialized set of children. |
| * @internal |
| */ |
| unmountChildren: function (renderedChildren) { |
| for (var name in renderedChildren) { |
| if (renderedChildren.hasOwnProperty(name)) { |
| var renderedChild = renderedChildren[name]; |
| ReactReconciler.unmountComponent(renderedChild); |
| } |
| } |
| } |
| |
| }; |
| |
| module.exports = ReactChildReconciler; |
| },{"132":132,"141":141,"142":142,"173":173,"84":84}],32:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactChildren |
| */ |
| |
| 'use strict'; |
| |
| var PooledClass = _dereq_(25); |
| var ReactElement = _dereq_(57); |
| |
| var emptyFunction = _dereq_(153); |
| var traverseAllChildren = _dereq_(142); |
| |
| var twoArgumentPooler = PooledClass.twoArgumentPooler; |
| var fourArgumentPooler = PooledClass.fourArgumentPooler; |
| |
| var userProvidedKeyEscapeRegex = /\/(?!\/)/g; |
| function escapeUserProvidedKey(text) { |
| return ('' + text).replace(userProvidedKeyEscapeRegex, '//'); |
| } |
| |
| /** |
| * PooledClass representing the bookkeeping associated with performing a child |
| * traversal. Allows avoiding binding callbacks. |
| * |
| * @constructor ForEachBookKeeping |
| * @param {!function} forEachFunction Function to perform traversal with. |
| * @param {?*} forEachContext Context to perform context with. |
| */ |
| function ForEachBookKeeping(forEachFunction, forEachContext) { |
| this.func = forEachFunction; |
| this.context = forEachContext; |
| this.count = 0; |
| } |
| ForEachBookKeeping.prototype.destructor = function () { |
| this.func = null; |
| this.context = null; |
| this.count = 0; |
| }; |
| PooledClass.addPoolingTo(ForEachBookKeeping, twoArgumentPooler); |
| |
| function forEachSingleChild(bookKeeping, child, name) { |
| var func = bookKeeping.func; |
| var context = bookKeeping.context; |
| |
| func.call(context, child, bookKeeping.count++); |
| } |
| |
| /** |
| * Iterates through children that are typically specified as `props.children`. |
| * |
| * The provided forEachFunc(child, index) will be called for each |
| * leaf child. |
| * |
| * @param {?*} children Children tree container. |
| * @param {function(*, int)} forEachFunc |
| * @param {*} forEachContext Context for forEachContext. |
| */ |
| function forEachChildren(children, forEachFunc, forEachContext) { |
| if (children == null) { |
| return children; |
| } |
| var traverseContext = ForEachBookKeeping.getPooled(forEachFunc, forEachContext); |
| traverseAllChildren(children, forEachSingleChild, traverseContext); |
| ForEachBookKeeping.release(traverseContext); |
| } |
| |
| /** |
| * PooledClass representing the bookkeeping associated with performing a child |
| * mapping. Allows avoiding binding callbacks. |
| * |
| * @constructor MapBookKeeping |
| * @param {!*} mapResult Object containing the ordered map of results. |
| * @param {!function} mapFunction Function to perform mapping with. |
| * @param {?*} mapContext Context to perform mapping with. |
| */ |
| function MapBookKeeping(mapResult, keyPrefix, mapFunction, mapContext) { |
| this.result = mapResult; |
| this.keyPrefix = keyPrefix; |
| this.func = mapFunction; |
| this.context = mapContext; |
| this.count = 0; |
| } |
| MapBookKeeping.prototype.destructor = function () { |
| this.result = null; |
| this.keyPrefix = null; |
| this.func = null; |
| this.context = null; |
| this.count = 0; |
| }; |
| PooledClass.addPoolingTo(MapBookKeeping, fourArgumentPooler); |
| |
| function mapSingleChildIntoContext(bookKeeping, child, childKey) { |
| var result = bookKeeping.result; |
| var keyPrefix = bookKeeping.keyPrefix; |
| var func = bookKeeping.func; |
| var context = bookKeeping.context; |
| |
| var mappedChild = func.call(context, child, bookKeeping.count++); |
| if (Array.isArray(mappedChild)) { |
| mapIntoWithKeyPrefixInternal(mappedChild, result, childKey, emptyFunction.thatReturnsArgument); |
| } else if (mappedChild != null) { |
| if (ReactElement.isValidElement(mappedChild)) { |
| mappedChild = ReactElement.cloneAndReplaceKey(mappedChild, |
| // Keep both the (mapped) and old keys if they differ, just as |
| // traverseAllChildren used to do for objects as children |
| keyPrefix + (mappedChild !== child ? escapeUserProvidedKey(mappedChild.key || '') + '/' : '') + childKey); |
| } |
| result.push(mappedChild); |
| } |
| } |
| |
| function mapIntoWithKeyPrefixInternal(children, array, prefix, func, context) { |
| var escapedPrefix = ''; |
| if (prefix != null) { |
| escapedPrefix = escapeUserProvidedKey(prefix) + '/'; |
| } |
| var traverseContext = MapBookKeeping.getPooled(array, escapedPrefix, func, context); |
| traverseAllChildren(children, mapSingleChildIntoContext, traverseContext); |
| MapBookKeeping.release(traverseContext); |
| } |
| |
| /** |
| * Maps children that are typically specified as `props.children`. |
| * |
| * The provided mapFunction(child, key, index) will be called for each |
| * leaf child. |
| * |
| * @param {?*} children Children tree container. |
| * @param {function(*, int)} func The map function. |
| * @param {*} context Context for mapFunction. |
| * @return {object} Object containing the ordered map of results. |
| */ |
| function mapChildren(children, func, context) { |
| if (children == null) { |
| return children; |
| } |
| var result = []; |
| mapIntoWithKeyPrefixInternal(children, result, null, func, context); |
| return result; |
| } |
| |
| function forEachSingleChildDummy(traverseContext, child, name) { |
| return null; |
| } |
| |
| /** |
| * Count the number of children that are typically specified as |
| * `props.children`. |
| * |
| * @param {?*} children Children tree container. |
| * @return {number} The number of children. |
| */ |
| function countChildren(children, context) { |
| return traverseAllChildren(children, forEachSingleChildDummy, null); |
| } |
| |
| /** |
| * Flatten a children object (typically specified as `props.children`) and |
| * return an array with appropriately re-keyed children. |
| */ |
| function toArray(children) { |
| var result = []; |
| mapIntoWithKeyPrefixInternal(children, result, null, emptyFunction.thatReturnsArgument); |
| return result; |
| } |
| |
| var ReactChildren = { |
| forEach: forEachChildren, |
| map: mapChildren, |
| mapIntoWithKeyPrefixInternal: mapIntoWithKeyPrefixInternal, |
| count: countChildren, |
| toArray: toArray |
| }; |
| |
| module.exports = ReactChildren; |
| },{"142":142,"153":153,"25":25,"57":57}],33:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactClass |
| */ |
| |
| 'use strict'; |
| |
| var ReactComponent = _dereq_(34); |
| var ReactElement = _dereq_(57); |
| var ReactPropTypeLocations = _dereq_(81); |
| var ReactPropTypeLocationNames = _dereq_(80); |
| var ReactNoopUpdateQueue = _dereq_(76); |
| |
| var assign = _dereq_(24); |
| var emptyObject = _dereq_(154); |
| var invariant = _dereq_(161); |
| var keyMirror = _dereq_(165); |
| var keyOf = _dereq_(166); |
| var warning = _dereq_(173); |
| |
| var MIXINS_KEY = keyOf({ mixins: null }); |
| |
| /** |
| * Policies that describe methods in `ReactClassInterface`. |
| */ |
| var SpecPolicy = keyMirror({ |
| /** |
| * These methods may be defined only once by the class specification or mixin. |
| */ |
| DEFINE_ONCE: null, |
| /** |
| * These methods may be defined by both the class specification and mixins. |
| * Subsequent definitions will be chained. These methods must return void. |
| */ |
| DEFINE_MANY: null, |
| /** |
| * These methods are overriding the base class. |
| */ |
| OVERRIDE_BASE: null, |
| /** |
| * These methods are similar to DEFINE_MANY, except we assume they return |
| * objects. We try to merge the keys of the return values of all the mixed in |
| * functions. If there is a key conflict we throw. |
| */ |
| DEFINE_MANY_MERGED: null |
| }); |
| |
| var injectedMixins = []; |
| |
| var warnedSetProps = false; |
| function warnSetProps() { |
| if (!warnedSetProps) { |
| warnedSetProps = true; |
| "development" !== 'production' ? warning(false, 'setProps(...) and replaceProps(...) are deprecated. ' + 'Instead, call render again at the top level.') : undefined; |
| } |
| } |
| |
| /** |
| * Composite components are higher-level components that compose other composite |
| * or native components. |
| * |
| * To create a new type of `ReactClass`, pass a specification of |
| * your new class to `React.createClass`. The only requirement of your class |
| * specification is that you implement a `render` method. |
| * |
| * var MyComponent = React.createClass({ |
| * render: function() { |
| * return <div>Hello World</div>; |
| * } |
| * }); |
| * |
| * The class specification supports a specific protocol of methods that have |
| * special meaning (e.g. `render`). See `ReactClassInterface` for |
| * more the comprehensive protocol. Any other properties and methods in the |
| * class specification will be available on the prototype. |
| * |
| * @interface ReactClassInterface |
| * @internal |
| */ |
| var ReactClassInterface = { |
| |
| /** |
| * An array of Mixin objects to include when defining your component. |
| * |
| * @type {array} |
| * @optional |
| */ |
| mixins: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * An object containing properties and methods that should be defined on |
| * the component's constructor instead of its prototype (static methods). |
| * |
| * @type {object} |
| * @optional |
| */ |
| statics: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Definition of prop types for this component. |
| * |
| * @type {object} |
| * @optional |
| */ |
| propTypes: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Definition of context types for this component. |
| * |
| * @type {object} |
| * @optional |
| */ |
| contextTypes: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Definition of context types this component sets for its children. |
| * |
| * @type {object} |
| * @optional |
| */ |
| childContextTypes: SpecPolicy.DEFINE_MANY, |
| |
| // ==== Definition methods ==== |
| |
| /** |
| * Invoked when the component is mounted. Values in the mapping will be set on |
| * `this.props` if that prop is not specified (i.e. using an `in` check). |
| * |
| * This method is invoked before `getInitialState` and therefore cannot rely |
| * on `this.state` or use `this.setState`. |
| * |
| * @return {object} |
| * @optional |
| */ |
| getDefaultProps: SpecPolicy.DEFINE_MANY_MERGED, |
| |
| /** |
| * Invoked once before the component is mounted. The return value will be used |
| * as the initial value of `this.state`. |
| * |
| * getInitialState: function() { |
| * return { |
| * isOn: false, |
| * fooBaz: new BazFoo() |
| * } |
| * } |
| * |
| * @return {object} |
| * @optional |
| */ |
| getInitialState: SpecPolicy.DEFINE_MANY_MERGED, |
| |
| /** |
| * @return {object} |
| * @optional |
| */ |
| getChildContext: SpecPolicy.DEFINE_MANY_MERGED, |
| |
| /** |
| * Uses props from `this.props` and state from `this.state` to render the |
| * structure of the component. |
| * |
| * No guarantees are made about when or how often this method is invoked, so |
| * it must not have side effects. |
| * |
| * render: function() { |
| * var name = this.props.name; |
| * return <div>Hello, {name}!</div>; |
| * } |
| * |
| * @return {ReactComponent} |
| * @nosideeffects |
| * @required |
| */ |
| render: SpecPolicy.DEFINE_ONCE, |
| |
| // ==== Delegate methods ==== |
| |
| /** |
| * Invoked when the component is initially created and about to be mounted. |
| * This may have side effects, but any external subscriptions or data created |
| * by this method must be cleaned up in `componentWillUnmount`. |
| * |
| * @optional |
| */ |
| componentWillMount: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Invoked when the component has been mounted and has a DOM representation. |
| * However, there is no guarantee that the DOM node is in the document. |
| * |
| * Use this as an opportunity to operate on the DOM when the component has |
| * been mounted (initialized and rendered) for the first time. |
| * |
| * @param {DOMElement} rootNode DOM element representing the component. |
| * @optional |
| */ |
| componentDidMount: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Invoked before the component receives new props. |
| * |
| * Use this as an opportunity to react to a prop transition by updating the |
| * state using `this.setState`. Current props are accessed via `this.props`. |
| * |
| * componentWillReceiveProps: function(nextProps, nextContext) { |
| * this.setState({ |
| * likesIncreasing: nextProps.likeCount > this.props.likeCount |
| * }); |
| * } |
| * |
| * NOTE: There is no equivalent `componentWillReceiveState`. An incoming prop |
| * transition may cause a state change, but the opposite is not true. If you |
| * need it, you are probably looking for `componentWillUpdate`. |
| * |
| * @param {object} nextProps |
| * @optional |
| */ |
| componentWillReceiveProps: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Invoked while deciding if the component should be updated as a result of |
| * receiving new props, state and/or context. |
| * |
| * Use this as an opportunity to `return false` when you're certain that the |
| * transition to the new props/state/context will not require a component |
| * update. |
| * |
| * shouldComponentUpdate: function(nextProps, nextState, nextContext) { |
| * return !equal(nextProps, this.props) || |
| * !equal(nextState, this.state) || |
| * !equal(nextContext, this.context); |
| * } |
| * |
| * @param {object} nextProps |
| * @param {?object} nextState |
| * @param {?object} nextContext |
| * @return {boolean} True if the component should update. |
| * @optional |
| */ |
| shouldComponentUpdate: SpecPolicy.DEFINE_ONCE, |
| |
| /** |
| * Invoked when the component is about to update due to a transition from |
| * `this.props`, `this.state` and `this.context` to `nextProps`, `nextState` |
| * and `nextContext`. |
| * |
| * Use this as an opportunity to perform preparation before an update occurs. |
| * |
| * NOTE: You **cannot** use `this.setState()` in this method. |
| * |
| * @param {object} nextProps |
| * @param {?object} nextState |
| * @param {?object} nextContext |
| * @param {ReactReconcileTransaction} transaction |
| * @optional |
| */ |
| componentWillUpdate: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Invoked when the component's DOM representation has been updated. |
| * |
| * Use this as an opportunity to operate on the DOM when the component has |
| * been updated. |
| * |
| * @param {object} prevProps |
| * @param {?object} prevState |
| * @param {?object} prevContext |
| * @param {DOMElement} rootNode DOM element representing the component. |
| * @optional |
| */ |
| componentDidUpdate: SpecPolicy.DEFINE_MANY, |
| |
| /** |
| * Invoked when the component is about to be removed from its parent and have |
| * its DOM representation destroyed. |
| * |
| * Use this as an opportunity to deallocate any external resources. |
| * |
| * NOTE: There is no `componentDidUnmount` since your component will have been |
| * destroyed by that point. |
| * |
| * @optional |
| */ |
| componentWillUnmount: SpecPolicy.DEFINE_MANY, |
| |
| // ==== Advanced methods ==== |
| |
| /** |
| * Updates the component's currently mounted DOM representation. |
| * |
| * By default, this implements React's rendering and reconciliation algorithm. |
| * Sophisticated clients may wish to override this. |
| * |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| * @overridable |
| */ |
| updateComponent: SpecPolicy.OVERRIDE_BASE |
| |
| }; |
| |
| /** |
| * Mapping from class specification keys to special processing functions. |
| * |
| * Although these are declared like instance properties in the specification |
| * when defining classes using `React.createClass`, they are actually static |
| * and are accessible on the constructor instead of the prototype. Despite |
| * being static, they must be defined outside of the "statics" key under |
| * which all other static methods are defined. |
| */ |
| var RESERVED_SPEC_KEYS = { |
| displayName: function (Constructor, displayName) { |
| Constructor.displayName = displayName; |
| }, |
| mixins: function (Constructor, mixins) { |
| if (mixins) { |
| for (var i = 0; i < mixins.length; i++) { |
| mixSpecIntoComponent(Constructor, mixins[i]); |
| } |
| } |
| }, |
| childContextTypes: function (Constructor, childContextTypes) { |
| if ("development" !== 'production') { |
| validateTypeDef(Constructor, childContextTypes, ReactPropTypeLocations.childContext); |
| } |
| Constructor.childContextTypes = assign({}, Constructor.childContextTypes, childContextTypes); |
| }, |
| contextTypes: function (Constructor, contextTypes) { |
| if ("development" !== 'production') { |
| validateTypeDef(Constructor, contextTypes, ReactPropTypeLocations.context); |
| } |
| Constructor.contextTypes = assign({}, Constructor.contextTypes, contextTypes); |
| }, |
| /** |
| * Special case getDefaultProps which should move into statics but requires |
| * automatic merging. |
| */ |
| getDefaultProps: function (Constructor, getDefaultProps) { |
| if (Constructor.getDefaultProps) { |
| Constructor.getDefaultProps = createMergedResultFunction(Constructor.getDefaultProps, getDefaultProps); |
| } else { |
| Constructor.getDefaultProps = getDefaultProps; |
| } |
| }, |
| propTypes: function (Constructor, propTypes) { |
| if ("development" !== 'production') { |
| validateTypeDef(Constructor, propTypes, ReactPropTypeLocations.prop); |
| } |
| Constructor.propTypes = assign({}, Constructor.propTypes, propTypes); |
| }, |
| statics: function (Constructor, statics) { |
| mixStaticSpecIntoComponent(Constructor, statics); |
| }, |
| autobind: function () {} }; |
| |
| // noop |
| function validateTypeDef(Constructor, typeDef, location) { |
| for (var propName in typeDef) { |
| if (typeDef.hasOwnProperty(propName)) { |
| // use a warning instead of an invariant so components |
| // don't show up in prod but not in __DEV__ |
| "development" !== 'production' ? warning(typeof typeDef[propName] === 'function', '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', Constructor.displayName || 'ReactClass', ReactPropTypeLocationNames[location], propName) : undefined; |
| } |
| } |
| } |
| |
| function validateMethodOverride(proto, name) { |
| var specPolicy = ReactClassInterface.hasOwnProperty(name) ? ReactClassInterface[name] : null; |
| |
| // Disallow overriding of base class methods unless explicitly allowed. |
| if (ReactClassMixin.hasOwnProperty(name)) { |
| !(specPolicy === SpecPolicy.OVERRIDE_BASE) ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to override ' + '`%s` from your class specification. Ensure that your method names ' + 'do not overlap with React methods.', name) : invariant(false) : undefined; |
| } |
| |
| // Disallow defining methods more than once unless explicitly allowed. |
| if (proto.hasOwnProperty(name)) { |
| !(specPolicy === SpecPolicy.DEFINE_MANY || specPolicy === SpecPolicy.DEFINE_MANY_MERGED) ? "development" !== 'production' ? invariant(false, 'ReactClassInterface: You are attempting to define ' + '`%s` on your component more than once. This conflict may be due ' + 'to a mixin.', name) : invariant(false) : undefined; |
| } |
| } |
| |
| /** |
| * Mixin helper which handles policy validation and reserved |
| * specification keys when building React classses. |
| */ |
| function mixSpecIntoComponent(Constructor, spec) { |
| if (!spec) { |
| return; |
| } |
| |
| !(typeof spec !== 'function') ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to ' + 'use a component class as a mixin. Instead, just use a regular object.') : invariant(false) : undefined; |
| !!ReactElement.isValidElement(spec) ? "development" !== 'production' ? invariant(false, 'ReactClass: You\'re attempting to ' + 'use a component as a mixin. Instead, just use a regular object.') : invariant(false) : undefined; |
| |
| var proto = Constructor.prototype; |
| |
| // By handling mixins before any other properties, we ensure the same |
| // chaining order is applied to methods with DEFINE_MANY policy, whether |
| // mixins are listed before or after these methods in the spec. |
| if (spec.hasOwnProperty(MIXINS_KEY)) { |
| RESERVED_SPEC_KEYS.mixins(Constructor, spec.mixins); |
| } |
| |
| for (var name in spec) { |
| if (!spec.hasOwnProperty(name)) { |
| continue; |
| } |
| |
| if (name === MIXINS_KEY) { |
| // We have already handled mixins in a special case above. |
| continue; |
| } |
| |
| var property = spec[name]; |
| validateMethodOverride(proto, name); |
| |
| if (RESERVED_SPEC_KEYS.hasOwnProperty(name)) { |
| RESERVED_SPEC_KEYS[name](Constructor, property); |
| } else { |
| // Setup methods on prototype: |
| // The following member methods should not be automatically bound: |
| // 1. Expected ReactClass methods (in the "interface"). |
| // 2. Overridden methods (that were mixed in). |
| var isReactClassMethod = ReactClassInterface.hasOwnProperty(name); |
| var isAlreadyDefined = proto.hasOwnProperty(name); |
| var isFunction = typeof property === 'function'; |
| var shouldAutoBind = isFunction && !isReactClassMethod && !isAlreadyDefined && spec.autobind !== false; |
| |
| if (shouldAutoBind) { |
| if (!proto.__reactAutoBindMap) { |
| proto.__reactAutoBindMap = {}; |
| } |
| proto.__reactAutoBindMap[name] = property; |
| proto[name] = property; |
| } else { |
| if (isAlreadyDefined) { |
| var specPolicy = ReactClassInterface[name]; |
| |
| // These cases should already be caught by validateMethodOverride. |
| !(isReactClassMethod && (specPolicy === SpecPolicy.DEFINE_MANY_MERGED || specPolicy === SpecPolicy.DEFINE_MANY)) ? "development" !== 'production' ? invariant(false, 'ReactClass: Unexpected spec policy %s for key %s ' + 'when mixing in component specs.', specPolicy, name) : invariant(false) : undefined; |
| |
| // For methods which are defined more than once, call the existing |
| // methods before calling the new property, merging if appropriate. |
| if (specPolicy === SpecPolicy.DEFINE_MANY_MERGED) { |
| proto[name] = createMergedResultFunction(proto[name], property); |
| } else if (specPolicy === SpecPolicy.DEFINE_MANY) { |
| proto[name] = createChainedFunction(proto[name], property); |
| } |
| } else { |
| proto[name] = property; |
| if ("development" !== 'production') { |
| // Add verbose displayName to the function, which helps when looking |
| // at profiling tools. |
| if (typeof property === 'function' && spec.displayName) { |
| proto[name].displayName = spec.displayName + '_' + name; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| function mixStaticSpecIntoComponent(Constructor, statics) { |
| if (!statics) { |
| return; |
| } |
| for (var name in statics) { |
| var property = statics[name]; |
| if (!statics.hasOwnProperty(name)) { |
| continue; |
| } |
| |
| var isReserved = (name in RESERVED_SPEC_KEYS); |
| !!isReserved ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define a reserved ' + 'property, `%s`, that shouldn\'t be on the "statics" key. Define it ' + 'as an instance property instead; it will still be accessible on the ' + 'constructor.', name) : invariant(false) : undefined; |
| |
| var isInherited = (name in Constructor); |
| !!isInherited ? "development" !== 'production' ? invariant(false, 'ReactClass: You are attempting to define ' + '`%s` on your component more than once. This conflict may be ' + 'due to a mixin.', name) : invariant(false) : undefined; |
| Constructor[name] = property; |
| } |
| } |
| |
| /** |
| * Merge two objects, but throw if both contain the same key. |
| * |
| * @param {object} one The first object, which is mutated. |
| * @param {object} two The second object |
| * @return {object} one after it has been mutated to contain everything in two. |
| */ |
| function mergeIntoWithNoDuplicateKeys(one, two) { |
| !(one && two && typeof one === 'object' && typeof two === 'object') ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): Cannot merge non-objects.') : invariant(false) : undefined; |
| |
| for (var key in two) { |
| if (two.hasOwnProperty(key)) { |
| !(one[key] === undefined) ? "development" !== 'production' ? invariant(false, 'mergeIntoWithNoDuplicateKeys(): ' + 'Tried to merge two objects with the same key: `%s`. This conflict ' + 'may be due to a mixin; in particular, this may be caused by two ' + 'getInitialState() or getDefaultProps() methods returning objects ' + 'with clashing keys.', key) : invariant(false) : undefined; |
| one[key] = two[key]; |
| } |
| } |
| return one; |
| } |
| |
| /** |
| * Creates a function that invokes two functions and merges their return values. |
| * |
| * @param {function} one Function to invoke first. |
| * @param {function} two Function to invoke second. |
| * @return {function} Function that invokes the two argument functions. |
| * @private |
| */ |
| function createMergedResultFunction(one, two) { |
| return function mergedResult() { |
| var a = one.apply(this, arguments); |
| var b = two.apply(this, arguments); |
| if (a == null) { |
| return b; |
| } else if (b == null) { |
| return a; |
| } |
| var c = {}; |
| mergeIntoWithNoDuplicateKeys(c, a); |
| mergeIntoWithNoDuplicateKeys(c, b); |
| return c; |
| }; |
| } |
| |
| /** |
| * Creates a function that invokes two functions and ignores their return vales. |
| * |
| * @param {function} one Function to invoke first. |
| * @param {function} two Function to invoke second. |
| * @return {function} Function that invokes the two argument functions. |
| * @private |
| */ |
| function createChainedFunction(one, two) { |
| return function chainedFunction() { |
| one.apply(this, arguments); |
| two.apply(this, arguments); |
| }; |
| } |
| |
| /** |
| * Binds a method to the component. |
| * |
| * @param {object} component Component whose method is going to be bound. |
| * @param {function} method Method to be bound. |
| * @return {function} The bound method. |
| */ |
| function bindAutoBindMethod(component, method) { |
| var boundMethod = method.bind(component); |
| if ("development" !== 'production') { |
| boundMethod.__reactBoundContext = component; |
| boundMethod.__reactBoundMethod = method; |
| boundMethod.__reactBoundArguments = null; |
| var componentName = component.constructor.displayName; |
| var _bind = boundMethod.bind; |
| /* eslint-disable block-scoped-var, no-undef */ |
| boundMethod.bind = function (newThis) { |
| for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { |
| args[_key - 1] = arguments[_key]; |
| } |
| |
| // User is trying to bind() an autobound method; we effectively will |
| // ignore the value of "this" that the user is trying to use, so |
| // let's warn. |
| if (newThis !== component && newThis !== null) { |
| "development" !== 'production' ? warning(false, 'bind(): React component methods may only be bound to the ' + 'component instance. See %s', componentName) : undefined; |
| } else if (!args.length) { |
| "development" !== 'production' ? warning(false, 'bind(): You are binding a component method to the component. ' + 'React does this for you automatically in a high-performance ' + 'way, so you can safely remove this call. See %s', componentName) : undefined; |
| return boundMethod; |
| } |
| var reboundMethod = _bind.apply(boundMethod, arguments); |
| reboundMethod.__reactBoundContext = component; |
| reboundMethod.__reactBoundMethod = method; |
| reboundMethod.__reactBoundArguments = args; |
| return reboundMethod; |
| /* eslint-enable */ |
| }; |
| } |
| return boundMethod; |
| } |
| |
| /** |
| * Binds all auto-bound methods in a component. |
| * |
| * @param {object} component Component whose method is going to be bound. |
| */ |
| function bindAutoBindMethods(component) { |
| for (var autoBindKey in component.__reactAutoBindMap) { |
| if (component.__reactAutoBindMap.hasOwnProperty(autoBindKey)) { |
| var method = component.__reactAutoBindMap[autoBindKey]; |
| component[autoBindKey] = bindAutoBindMethod(component, method); |
| } |
| } |
| } |
| |
| /** |
| * Add more to the ReactClass base class. These are all legacy features and |
| * therefore not already part of the modern ReactComponent. |
| */ |
| var ReactClassMixin = { |
| |
| /** |
| * TODO: This will be deprecated because state should always keep a consistent |
| * type signature and the only use case for this, is to avoid that. |
| */ |
| replaceState: function (newState, callback) { |
| this.updater.enqueueReplaceState(this, newState); |
| if (callback) { |
| this.updater.enqueueCallback(this, callback); |
| } |
| }, |
| |
| /** |
| * Checks whether or not this composite component is mounted. |
| * @return {boolean} True if mounted, false otherwise. |
| * @protected |
| * @final |
| */ |
| isMounted: function () { |
| return this.updater.isMounted(this); |
| }, |
| |
| /** |
| * Sets a subset of the props. |
| * |
| * @param {object} partialProps Subset of the next props. |
| * @param {?function} callback Called after props are updated. |
| * @final |
| * @public |
| * @deprecated |
| */ |
| setProps: function (partialProps, callback) { |
| if ("development" !== 'production') { |
| warnSetProps(); |
| } |
| this.updater.enqueueSetProps(this, partialProps); |
| if (callback) { |
| this.updater.enqueueCallback(this, callback); |
| } |
| }, |
| |
| /** |
| * Replace all the props. |
| * |
| * @param {object} newProps Subset of the next props. |
| * @param {?function} callback Called after props are updated. |
| * @final |
| * @public |
| * @deprecated |
| */ |
| replaceProps: function (newProps, callback) { |
| if ("development" !== 'production') { |
| warnSetProps(); |
| } |
| this.updater.enqueueReplaceProps(this, newProps); |
| if (callback) { |
| this.updater.enqueueCallback(this, callback); |
| } |
| } |
| }; |
| |
| var ReactClassComponent = function () {}; |
| assign(ReactClassComponent.prototype, ReactComponent.prototype, ReactClassMixin); |
| |
| /** |
| * Module for creating composite components. |
| * |
| * @class ReactClass |
| */ |
| var ReactClass = { |
| |
| /** |
| * Creates a composite component class given a class specification. |
| * |
| * @param {object} spec Class specification (which must define `render`). |
| * @return {function} Component constructor function. |
| * @public |
| */ |
| createClass: function (spec) { |
| var Constructor = function (props, context, updater) { |
| // This constructor is overridden by mocks. The argument is used |
| // by mocks to assert on what gets mounted. |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(this instanceof Constructor, 'Something is calling a React component directly. Use a factory or ' + 'JSX instead. See: https://fb.me/react-legacyfactory') : undefined; |
| } |
| |
| // Wire up auto-binding |
| if (this.__reactAutoBindMap) { |
| bindAutoBindMethods(this); |
| } |
| |
| this.props = props; |
| this.context = context; |
| this.refs = emptyObject; |
| this.updater = updater || ReactNoopUpdateQueue; |
| |
| this.state = null; |
| |
| // ReactClasses doesn't have constructors. Instead, they use the |
| // getInitialState and componentWillMount methods for initialization. |
| |
| var initialState = this.getInitialState ? this.getInitialState() : null; |
| if ("development" !== 'production') { |
| // We allow auto-mocks to proceed as if they're returning null. |
| if (typeof initialState === 'undefined' && this.getInitialState._isMockFunction) { |
| // This is probably bad practice. Consider warning here and |
| // deprecating this convenience. |
| initialState = null; |
| } |
| } |
| !(typeof initialState === 'object' && !Array.isArray(initialState)) ? "development" !== 'production' ? invariant(false, '%s.getInitialState(): must return an object or null', Constructor.displayName || 'ReactCompositeComponent') : invariant(false) : undefined; |
| |
| this.state = initialState; |
| }; |
| Constructor.prototype = new ReactClassComponent(); |
| Constructor.prototype.constructor = Constructor; |
| |
| injectedMixins.forEach(mixSpecIntoComponent.bind(null, Constructor)); |
| |
| mixSpecIntoComponent(Constructor, spec); |
| |
| // Initialize the defaultProps property after all mixins have been merged. |
| if (Constructor.getDefaultProps) { |
| Constructor.defaultProps = Constructor.getDefaultProps(); |
| } |
| |
| if ("development" !== 'production') { |
| // This is a tag to indicate that the use of these method names is ok, |
| // since it's used with createClass. If it's not, then it's likely a |
| // mistake so we'll warn you to use the static property, property |
| // initializer or constructor respectively. |
| if (Constructor.getDefaultProps) { |
| Constructor.getDefaultProps.isReactClassApproved = {}; |
| } |
| if (Constructor.prototype.getInitialState) { |
| Constructor.prototype.getInitialState.isReactClassApproved = {}; |
| } |
| } |
| |
| !Constructor.prototype.render ? "development" !== 'production' ? invariant(false, 'createClass(...): Class specification must implement a `render` method.') : invariant(false) : undefined; |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(!Constructor.prototype.componentShouldUpdate, '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', spec.displayName || 'A component') : undefined; |
| "development" !== 'production' ? warning(!Constructor.prototype.componentWillRecieveProps, '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', spec.displayName || 'A component') : undefined; |
| } |
| |
| // Reduce time spent doing lookups by setting these on the prototype. |
| for (var methodName in ReactClassInterface) { |
| if (!Constructor.prototype[methodName]) { |
| Constructor.prototype[methodName] = null; |
| } |
| } |
| |
| return Constructor; |
| }, |
| |
| injection: { |
| injectMixin: function (mixin) { |
| injectedMixins.push(mixin); |
| } |
| } |
| |
| }; |
| |
| module.exports = ReactClass; |
| },{"154":154,"161":161,"165":165,"166":166,"173":173,"24":24,"34":34,"57":57,"76":76,"80":80,"81":81}],34:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactComponent |
| */ |
| |
| 'use strict'; |
| |
| var ReactNoopUpdateQueue = _dereq_(76); |
| |
| var canDefineProperty = _dereq_(117); |
| var emptyObject = _dereq_(154); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| /** |
| * Base class helpers for the updating state of a component. |
| */ |
| function ReactComponent(props, context, updater) { |
| this.props = props; |
| this.context = context; |
| this.refs = emptyObject; |
| // We initialize the default updater but the real one gets injected by the |
| // renderer. |
| this.updater = updater || ReactNoopUpdateQueue; |
| } |
| |
| ReactComponent.prototype.isReactComponent = {}; |
| |
| /** |
| * Sets a subset of the state. Always use this to mutate |
| * state. You should treat `this.state` as immutable. |
| * |
| * There is no guarantee that `this.state` will be immediately updated, so |
| * accessing `this.state` after calling this method may return the old value. |
| * |
| * There is no guarantee that calls to `setState` will run synchronously, |
| * as they may eventually be batched together. You can provide an optional |
| * callback that will be executed when the call to setState is actually |
| * completed. |
| * |
| * When a function is provided to setState, it will be called at some point in |
| * the future (not synchronously). It will be called with the up to date |
| * component arguments (state, props, context). These values can be different |
| * from this.* because your function may be called after receiveProps but before |
| * shouldComponentUpdate, and this new state, props, and context will not yet be |
| * assigned to this. |
| * |
| * @param {object|function} partialState Next partial state or function to |
| * produce next partial state to be merged with current state. |
| * @param {?function} callback Called after state is updated. |
| * @final |
| * @protected |
| */ |
| ReactComponent.prototype.setState = function (partialState, callback) { |
| !(typeof partialState === 'object' || typeof partialState === 'function' || partialState == null) ? "development" !== 'production' ? invariant(false, 'setState(...): takes an object of state variables to update or a ' + 'function which returns an object of state variables.') : invariant(false) : undefined; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(partialState != null, 'setState(...): You passed an undefined or null state object; ' + 'instead, use forceUpdate().') : undefined; |
| } |
| this.updater.enqueueSetState(this, partialState); |
| if (callback) { |
| this.updater.enqueueCallback(this, callback); |
| } |
| }; |
| |
| /** |
| * Forces an update. This should only be invoked when it is known with |
| * certainty that we are **not** in a DOM transaction. |
| * |
| * You may want to call this when you know that some deeper aspect of the |
| * component's state has changed but `setState` was not called. |
| * |
| * This will not invoke `shouldComponentUpdate`, but it will invoke |
| * `componentWillUpdate` and `componentDidUpdate`. |
| * |
| * @param {?function} callback Called after update is complete. |
| * @final |
| * @protected |
| */ |
| ReactComponent.prototype.forceUpdate = function (callback) { |
| this.updater.enqueueForceUpdate(this); |
| if (callback) { |
| this.updater.enqueueCallback(this, callback); |
| } |
| }; |
| |
| /** |
| * Deprecated APIs. These APIs used to exist on classic React classes but since |
| * we would like to deprecate them, we're not going to move them over to this |
| * modern base class. Instead, we define a getter that warns if it's accessed. |
| */ |
| if ("development" !== 'production') { |
| var deprecatedAPIs = { |
| getDOMNode: ['getDOMNode', 'Use ReactDOM.findDOMNode(component) instead.'], |
| isMounted: ['isMounted', 'Instead, make sure to clean up subscriptions and pending requests in ' + 'componentWillUnmount to prevent memory leaks.'], |
| replaceProps: ['replaceProps', 'Instead, call render again at the top level.'], |
| replaceState: ['replaceState', 'Refactor your code to use setState instead (see ' + 'https://github.com/facebook/react/issues/3236).'], |
| setProps: ['setProps', 'Instead, call render again at the top level.'] |
| }; |
| var defineDeprecationWarning = function (methodName, info) { |
| if (canDefineProperty) { |
| Object.defineProperty(ReactComponent.prototype, methodName, { |
| get: function () { |
| "development" !== 'production' ? warning(false, '%s(...) is deprecated in plain JavaScript React classes. %s', info[0], info[1]) : undefined; |
| return undefined; |
| } |
| }); |
| } |
| }; |
| for (var fnName in deprecatedAPIs) { |
| if (deprecatedAPIs.hasOwnProperty(fnName)) { |
| defineDeprecationWarning(fnName, deprecatedAPIs[fnName]); |
| } |
| } |
| } |
| |
| module.exports = ReactComponent; |
| },{"117":117,"154":154,"161":161,"173":173,"76":76}],35:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactComponentBrowserEnvironment |
| */ |
| |
| 'use strict'; |
| |
| var ReactDOMIDOperations = _dereq_(45); |
| var ReactMount = _dereq_(72); |
| |
| /** |
| * Abstracts away all functionality of the reconciler that requires knowledge of |
| * the browser context. TODO: These callers should be refactored to avoid the |
| * need for this injection. |
| */ |
| var ReactComponentBrowserEnvironment = { |
| |
| processChildrenUpdates: ReactDOMIDOperations.dangerouslyProcessChildrenUpdates, |
| |
| replaceNodeWithMarkupByID: ReactDOMIDOperations.dangerouslyReplaceNodeWithMarkupByID, |
| |
| /** |
| * If a particular environment requires that some resources be cleaned up, |
| * specify this in the injected Mixin. In the DOM, we would likely want to |
| * purge any cached node ID lookups. |
| * |
| * @private |
| */ |
| unmountIDFromEnvironment: function (rootNodeID) { |
| ReactMount.purgeID(rootNodeID); |
| } |
| |
| }; |
| |
| module.exports = ReactComponentBrowserEnvironment; |
| },{"45":45,"72":72}],36:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactComponentEnvironment |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| var injected = false; |
| |
| var ReactComponentEnvironment = { |
| |
| /** |
| * Optionally injectable environment dependent cleanup hook. (server vs. |
| * browser etc). Example: A browser system caches DOM nodes based on component |
| * ID and must remove that cache entry when this instance is unmounted. |
| */ |
| unmountIDFromEnvironment: null, |
| |
| /** |
| * Optionally injectable hook for swapping out mount images in the middle of |
| * the tree. |
| */ |
| replaceNodeWithMarkupByID: null, |
| |
| /** |
| * Optionally injectable hook for processing a queue of child updates. Will |
| * later move into MultiChildComponents. |
| */ |
| processChildrenUpdates: null, |
| |
| injection: { |
| injectEnvironment: function (environment) { |
| !!injected ? "development" !== 'production' ? invariant(false, 'ReactCompositeComponent: injectEnvironment() can only be called once.') : invariant(false) : undefined; |
| ReactComponentEnvironment.unmountIDFromEnvironment = environment.unmountIDFromEnvironment; |
| ReactComponentEnvironment.replaceNodeWithMarkupByID = environment.replaceNodeWithMarkupByID; |
| ReactComponentEnvironment.processChildrenUpdates = environment.processChildrenUpdates; |
| injected = true; |
| } |
| } |
| |
| }; |
| |
| module.exports = ReactComponentEnvironment; |
| },{"161":161}],37:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactComponentWithPureRenderMixin |
| */ |
| |
| 'use strict'; |
| |
| var shallowCompare = _dereq_(140); |
| |
| /** |
| * If your React component's render function is "pure", e.g. it will render the |
| * same result given the same props and state, provide this Mixin for a |
| * considerable performance boost. |
| * |
| * Most React components have pure render functions. |
| * |
| * Example: |
| * |
| * var ReactComponentWithPureRenderMixin = |
| * require('ReactComponentWithPureRenderMixin'); |
| * React.createClass({ |
| * mixins: [ReactComponentWithPureRenderMixin], |
| * |
| * render: function() { |
| * return <div className={this.props.className}>foo</div>; |
| * } |
| * }); |
| * |
| * Note: This only checks shallow equality for props and state. If these contain |
| * complex data structures this mixin may have false-negatives for deeper |
| * differences. Only mixin to components which have simple props and state, or |
| * use `forceUpdate()` when you know deep data structures have changed. |
| */ |
| var ReactComponentWithPureRenderMixin = { |
| shouldComponentUpdate: function (nextProps, nextState) { |
| return shallowCompare(this, nextProps, nextState); |
| } |
| }; |
| |
| module.exports = ReactComponentWithPureRenderMixin; |
| },{"140":140}],38:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactCompositeComponent |
| */ |
| |
| 'use strict'; |
| |
| var ReactComponentEnvironment = _dereq_(36); |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactElement = _dereq_(57); |
| var ReactInstanceMap = _dereq_(68); |
| var ReactPerf = _dereq_(78); |
| var ReactPropTypeLocations = _dereq_(81); |
| var ReactPropTypeLocationNames = _dereq_(80); |
| var ReactReconciler = _dereq_(84); |
| var ReactUpdateQueue = _dereq_(95); |
| |
| var assign = _dereq_(24); |
| var emptyObject = _dereq_(154); |
| var invariant = _dereq_(161); |
| var shouldUpdateReactComponent = _dereq_(141); |
| var warning = _dereq_(173); |
| |
| function getDeclarationErrorAddendum(component) { |
| var owner = component._currentElement._owner || null; |
| if (owner) { |
| var name = owner.getName(); |
| if (name) { |
| return ' Check the render method of `' + name + '`.'; |
| } |
| } |
| return ''; |
| } |
| |
| function StatelessComponent(Component) {} |
| StatelessComponent.prototype.render = function () { |
| var Component = ReactInstanceMap.get(this)._currentElement.type; |
| return Component(this.props, this.context, this.updater); |
| }; |
| |
| /** |
| * ------------------ The Life-Cycle of a Composite Component ------------------ |
| * |
| * - constructor: Initialization of state. The instance is now retained. |
| * - componentWillMount |
| * - render |
| * - [children's constructors] |
| * - [children's componentWillMount and render] |
| * - [children's componentDidMount] |
| * - componentDidMount |
| * |
| * Update Phases: |
| * - componentWillReceiveProps (only called if parent updated) |
| * - shouldComponentUpdate |
| * - componentWillUpdate |
| * - render |
| * - [children's constructors or receive props phases] |
| * - componentDidUpdate |
| * |
| * - componentWillUnmount |
| * - [children's componentWillUnmount] |
| * - [children destroyed] |
| * - (destroyed): The instance is now blank, released by React and ready for GC. |
| * |
| * ----------------------------------------------------------------------------- |
| */ |
| |
| /** |
| * An incrementing ID assigned to each component when it is mounted. This is |
| * used to enforce the order in which `ReactUpdates` updates dirty components. |
| * |
| * @private |
| */ |
| var nextMountID = 1; |
| |
| /** |
| * @lends {ReactCompositeComponent.prototype} |
| */ |
| var ReactCompositeComponentMixin = { |
| |
| /** |
| * Base constructor for all composite component. |
| * |
| * @param {ReactElement} element |
| * @final |
| * @internal |
| */ |
| construct: function (element) { |
| this._currentElement = element; |
| this._rootNodeID = null; |
| this._instance = null; |
| |
| // See ReactUpdateQueue |
| this._pendingElement = null; |
| this._pendingStateQueue = null; |
| this._pendingReplaceState = false; |
| this._pendingForceUpdate = false; |
| |
| this._renderedComponent = null; |
| |
| this._context = null; |
| this._mountOrder = 0; |
| this._topLevelWrapper = null; |
| |
| // See ReactUpdates and ReactUpdateQueue. |
| this._pendingCallbacks = null; |
| }, |
| |
| /** |
| * Initializes the component, renders markup, and registers event listeners. |
| * |
| * @param {string} rootID DOM ID of the root node. |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @return {?string} Rendered markup to be inserted into the DOM. |
| * @final |
| * @internal |
| */ |
| mountComponent: function (rootID, transaction, context) { |
| this._context = context; |
| this._mountOrder = nextMountID++; |
| this._rootNodeID = rootID; |
| |
| var publicProps = this._processProps(this._currentElement.props); |
| var publicContext = this._processContext(context); |
| |
| var Component = this._currentElement.type; |
| |
| // Initialize the public class |
| var inst; |
| var renderedElement; |
| |
| // This is a way to detect if Component is a stateless arrow function |
| // component, which is not newable. It might not be 100% reliable but is |
| // something we can do until we start detecting that Component extends |
| // React.Component. We already assume that typeof Component === 'function'. |
| var canInstantiate = ('prototype' in Component); |
| |
| if (canInstantiate) { |
| if ("development" !== 'production') { |
| ReactCurrentOwner.current = this; |
| try { |
| inst = new Component(publicProps, publicContext, ReactUpdateQueue); |
| } finally { |
| ReactCurrentOwner.current = null; |
| } |
| } else { |
| inst = new Component(publicProps, publicContext, ReactUpdateQueue); |
| } |
| } |
| |
| if (!canInstantiate || inst === null || inst === false || ReactElement.isValidElement(inst)) { |
| renderedElement = inst; |
| inst = new StatelessComponent(Component); |
| } |
| |
| if ("development" !== 'production') { |
| // This will throw later in _renderValidatedComponent, but add an early |
| // warning now to help debugging |
| if (inst.render == null) { |
| "development" !== 'production' ? warning(false, '%s(...): No `render` method found on the returned component ' + 'instance: you may have forgotten to define `render`, returned ' + 'null/false from a stateless component, or tried to render an ' + 'element whose type is a function that isn\'t a React component.', Component.displayName || Component.name || 'Component') : undefined; |
| } else { |
| // We support ES6 inheriting from React.Component, the module pattern, |
| // and stateless components, but not ES6 classes that don't extend |
| "development" !== 'production' ? warning(Component.prototype && Component.prototype.isReactComponent || !canInstantiate || !(inst instanceof Component), '%s(...): React component classes must extend React.Component.', Component.displayName || Component.name || 'Component') : undefined; |
| } |
| } |
| |
| // These should be set up in the constructor, but as a convenience for |
| // simpler class abstractions, we set them up after the fact. |
| inst.props = publicProps; |
| inst.context = publicContext; |
| inst.refs = emptyObject; |
| inst.updater = ReactUpdateQueue; |
| |
| this._instance = inst; |
| |
| // Store a reference from the instance back to the internal representation |
| ReactInstanceMap.set(inst, this); |
| |
| if ("development" !== 'production') { |
| // Since plain JS classes are defined without any special initialization |
| // logic, we can not catch common errors early. Therefore, we have to |
| // catch them here, at initialization time, instead. |
| "development" !== 'production' ? warning(!inst.getInitialState || inst.getInitialState.isReactClassApproved, 'getInitialState was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Did you mean to define a state property instead?', this.getName() || 'a component') : undefined; |
| "development" !== 'production' ? warning(!inst.getDefaultProps || inst.getDefaultProps.isReactClassApproved, 'getDefaultProps was defined on %s, a plain JavaScript class. ' + 'This is only supported for classes created using React.createClass. ' + 'Use a static property to define defaultProps instead.', this.getName() || 'a component') : undefined; |
| "development" !== 'production' ? warning(!inst.propTypes, 'propTypes was defined as an instance property on %s. Use a static ' + 'property to define propTypes instead.', this.getName() || 'a component') : undefined; |
| "development" !== 'production' ? warning(!inst.contextTypes, 'contextTypes was defined as an instance property on %s. Use a ' + 'static property to define contextTypes instead.', this.getName() || 'a component') : undefined; |
| "development" !== 'production' ? warning(typeof inst.componentShouldUpdate !== 'function', '%s has a method called ' + 'componentShouldUpdate(). Did you mean shouldComponentUpdate()? ' + 'The name is phrased as a question because the function is ' + 'expected to return a value.', this.getName() || 'A component') : undefined; |
| "development" !== 'production' ? warning(typeof inst.componentDidUnmount !== 'function', '%s has a method called ' + 'componentDidUnmount(). But there is no such lifecycle method. ' + 'Did you mean componentWillUnmount()?', this.getName() || 'A component') : undefined; |
| "development" !== 'production' ? warning(typeof inst.componentWillRecieveProps !== 'function', '%s has a method called ' + 'componentWillRecieveProps(). Did you mean componentWillReceiveProps()?', this.getName() || 'A component') : undefined; |
| } |
| |
| var initialState = inst.state; |
| if (initialState === undefined) { |
| inst.state = initialState = null; |
| } |
| !(typeof initialState === 'object' && !Array.isArray(initialState)) ? "development" !== 'production' ? invariant(false, '%s.state: must be set to an object or null', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined; |
| |
| this._pendingStateQueue = null; |
| this._pendingReplaceState = false; |
| this._pendingForceUpdate = false; |
| |
| if (inst.componentWillMount) { |
| inst.componentWillMount(); |
| // When mounting, calls to `setState` by `componentWillMount` will set |
| // `this._pendingStateQueue` without triggering a re-render. |
| if (this._pendingStateQueue) { |
| inst.state = this._processPendingState(inst.props, inst.context); |
| } |
| } |
| |
| // If not a stateless component, we now render |
| if (renderedElement === undefined) { |
| renderedElement = this._renderValidatedComponent(); |
| } |
| |
| this._renderedComponent = this._instantiateReactComponent(renderedElement); |
| |
| var markup = ReactReconciler.mountComponent(this._renderedComponent, rootID, transaction, this._processChildContext(context)); |
| if (inst.componentDidMount) { |
| transaction.getReactMountReady().enqueue(inst.componentDidMount, inst); |
| } |
| |
| return markup; |
| }, |
| |
| /** |
| * Releases any resources allocated by `mountComponent`. |
| * |
| * @final |
| * @internal |
| */ |
| unmountComponent: function () { |
| var inst = this._instance; |
| |
| if (inst.componentWillUnmount) { |
| inst.componentWillUnmount(); |
| } |
| |
| ReactReconciler.unmountComponent(this._renderedComponent); |
| this._renderedComponent = null; |
| this._instance = null; |
| |
| // Reset pending fields |
| // Even if this component is scheduled for another update in ReactUpdates, |
| // it would still be ignored because these fields are reset. |
| this._pendingStateQueue = null; |
| this._pendingReplaceState = false; |
| this._pendingForceUpdate = false; |
| this._pendingCallbacks = null; |
| this._pendingElement = null; |
| |
| // These fields do not really need to be reset since this object is no |
| // longer accessible. |
| this._context = null; |
| this._rootNodeID = null; |
| this._topLevelWrapper = null; |
| |
| // Delete the reference from the instance to this internal representation |
| // which allow the internals to be properly cleaned up even if the user |
| // leaks a reference to the public instance. |
| ReactInstanceMap.remove(inst); |
| |
| // Some existing components rely on inst.props even after they've been |
| // destroyed (in event handlers). |
| // TODO: inst.props = null; |
| // TODO: inst.state = null; |
| // TODO: inst.context = null; |
| }, |
| |
| /** |
| * Filters the context object to only contain keys specified in |
| * `contextTypes` |
| * |
| * @param {object} context |
| * @return {?object} |
| * @private |
| */ |
| _maskContext: function (context) { |
| var maskedContext = null; |
| var Component = this._currentElement.type; |
| var contextTypes = Component.contextTypes; |
| if (!contextTypes) { |
| return emptyObject; |
| } |
| maskedContext = {}; |
| for (var contextName in contextTypes) { |
| maskedContext[contextName] = context[contextName]; |
| } |
| return maskedContext; |
| }, |
| |
| /** |
| * Filters the context object to only contain keys specified in |
| * `contextTypes`, and asserts that they are valid. |
| * |
| * @param {object} context |
| * @return {?object} |
| * @private |
| */ |
| _processContext: function (context) { |
| var maskedContext = this._maskContext(context); |
| if ("development" !== 'production') { |
| var Component = this._currentElement.type; |
| if (Component.contextTypes) { |
| this._checkPropTypes(Component.contextTypes, maskedContext, ReactPropTypeLocations.context); |
| } |
| } |
| return maskedContext; |
| }, |
| |
| /** |
| * @param {object} currentContext |
| * @return {object} |
| * @private |
| */ |
| _processChildContext: function (currentContext) { |
| var Component = this._currentElement.type; |
| var inst = this._instance; |
| var childContext = inst.getChildContext && inst.getChildContext(); |
| if (childContext) { |
| !(typeof Component.childContextTypes === 'object') ? "development" !== 'production' ? invariant(false, '%s.getChildContext(): childContextTypes must be defined in order to ' + 'use getChildContext().', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined; |
| if ("development" !== 'production') { |
| this._checkPropTypes(Component.childContextTypes, childContext, ReactPropTypeLocations.childContext); |
| } |
| for (var name in childContext) { |
| !(name in Component.childContextTypes) ? "development" !== 'production' ? invariant(false, '%s.getChildContext(): key "%s" is not defined in childContextTypes.', this.getName() || 'ReactCompositeComponent', name) : invariant(false) : undefined; |
| } |
| return assign({}, currentContext, childContext); |
| } |
| return currentContext; |
| }, |
| |
| /** |
| * Processes props by setting default values for unspecified props and |
| * asserting that the props are valid. Does not mutate its argument; returns |
| * a new props object with defaults merged in. |
| * |
| * @param {object} newProps |
| * @return {object} |
| * @private |
| */ |
| _processProps: function (newProps) { |
| if ("development" !== 'production') { |
| var Component = this._currentElement.type; |
| if (Component.propTypes) { |
| this._checkPropTypes(Component.propTypes, newProps, ReactPropTypeLocations.prop); |
| } |
| } |
| return newProps; |
| }, |
| |
| /** |
| * Assert that the props are valid |
| * |
| * @param {object} propTypes Map of prop name to a ReactPropType |
| * @param {object} props |
| * @param {string} location e.g. "prop", "context", "child context" |
| * @private |
| */ |
| _checkPropTypes: function (propTypes, props, location) { |
| // TODO: Stop validating prop types here and only use the element |
| // validation. |
| var componentName = this.getName(); |
| for (var propName in propTypes) { |
| if (propTypes.hasOwnProperty(propName)) { |
| var error; |
| try { |
| // This is intentionally an invariant that gets caught. It's the same |
| // behavior as without this statement except with a better message. |
| !(typeof propTypes[propName] === 'function') ? "development" !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually ' + 'from React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], propName) : invariant(false) : undefined; |
| error = propTypes[propName](props, propName, componentName, location); |
| } catch (ex) { |
| error = ex; |
| } |
| if (error instanceof Error) { |
| // We may want to extend this logic for similar errors in |
| // top-level render calls, so I'm abstracting it away into |
| // a function to minimize refactoring in the future |
| var addendum = getDeclarationErrorAddendum(this); |
| |
| if (location === ReactPropTypeLocations.prop) { |
| // Preface gives us something to blacklist in warning module |
| "development" !== 'production' ? warning(false, 'Failed Composite propType: %s%s', error.message, addendum) : undefined; |
| } else { |
| "development" !== 'production' ? warning(false, 'Failed Context Types: %s%s', error.message, addendum) : undefined; |
| } |
| } |
| } |
| } |
| }, |
| |
| receiveComponent: function (nextElement, transaction, nextContext) { |
| var prevElement = this._currentElement; |
| var prevContext = this._context; |
| |
| this._pendingElement = null; |
| |
| this.updateComponent(transaction, prevElement, nextElement, prevContext, nextContext); |
| }, |
| |
| /** |
| * If any of `_pendingElement`, `_pendingStateQueue`, or `_pendingForceUpdate` |
| * is set, update the component. |
| * |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| */ |
| performUpdateIfNecessary: function (transaction) { |
| if (this._pendingElement != null) { |
| ReactReconciler.receiveComponent(this, this._pendingElement || this._currentElement, transaction, this._context); |
| } |
| |
| if (this._pendingStateQueue !== null || this._pendingForceUpdate) { |
| this.updateComponent(transaction, this._currentElement, this._currentElement, this._context, this._context); |
| } |
| }, |
| |
| /** |
| * Perform an update to a mounted component. The componentWillReceiveProps and |
| * shouldComponentUpdate methods are called, then (assuming the update isn't |
| * skipped) the remaining update lifecycle methods are called and the DOM |
| * representation is updated. |
| * |
| * By default, this implements React's rendering and reconciliation algorithm. |
| * Sophisticated clients may wish to override this. |
| * |
| * @param {ReactReconcileTransaction} transaction |
| * @param {ReactElement} prevParentElement |
| * @param {ReactElement} nextParentElement |
| * @internal |
| * @overridable |
| */ |
| updateComponent: function (transaction, prevParentElement, nextParentElement, prevUnmaskedContext, nextUnmaskedContext) { |
| var inst = this._instance; |
| |
| var nextContext = this._context === nextUnmaskedContext ? inst.context : this._processContext(nextUnmaskedContext); |
| var nextProps; |
| |
| // Distinguish between a props update versus a simple state update |
| if (prevParentElement === nextParentElement) { |
| // Skip checking prop types again -- we don't read inst.props to avoid |
| // warning for DOM component props in this upgrade |
| nextProps = nextParentElement.props; |
| } else { |
| nextProps = this._processProps(nextParentElement.props); |
| // An update here will schedule an update but immediately set |
| // _pendingStateQueue which will ensure that any state updates gets |
| // immediately reconciled instead of waiting for the next batch. |
| |
| if (inst.componentWillReceiveProps) { |
| inst.componentWillReceiveProps(nextProps, nextContext); |
| } |
| } |
| |
| var nextState = this._processPendingState(nextProps, nextContext); |
| |
| var shouldUpdate = this._pendingForceUpdate || !inst.shouldComponentUpdate || inst.shouldComponentUpdate(nextProps, nextState, nextContext); |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(typeof shouldUpdate !== 'undefined', '%s.shouldComponentUpdate(): Returned undefined instead of a ' + 'boolean value. Make sure to return true or false.', this.getName() || 'ReactCompositeComponent') : undefined; |
| } |
| |
| if (shouldUpdate) { |
| this._pendingForceUpdate = false; |
| // Will set `this.props`, `this.state` and `this.context`. |
| this._performComponentUpdate(nextParentElement, nextProps, nextState, nextContext, transaction, nextUnmaskedContext); |
| } else { |
| // If it's determined that a component should not update, we still want |
| // to set props and state but we shortcut the rest of the update. |
| this._currentElement = nextParentElement; |
| this._context = nextUnmaskedContext; |
| inst.props = nextProps; |
| inst.state = nextState; |
| inst.context = nextContext; |
| } |
| }, |
| |
| _processPendingState: function (props, context) { |
| var inst = this._instance; |
| var queue = this._pendingStateQueue; |
| var replace = this._pendingReplaceState; |
| this._pendingReplaceState = false; |
| this._pendingStateQueue = null; |
| |
| if (!queue) { |
| return inst.state; |
| } |
| |
| if (replace && queue.length === 1) { |
| return queue[0]; |
| } |
| |
| var nextState = assign({}, replace ? queue[0] : inst.state); |
| for (var i = replace ? 1 : 0; i < queue.length; i++) { |
| var partial = queue[i]; |
| assign(nextState, typeof partial === 'function' ? partial.call(inst, nextState, props, context) : partial); |
| } |
| |
| return nextState; |
| }, |
| |
| /** |
| * Merges new props and state, notifies delegate methods of update and |
| * performs update. |
| * |
| * @param {ReactElement} nextElement Next element |
| * @param {object} nextProps Next public object to set as properties. |
| * @param {?object} nextState Next object to set as state. |
| * @param {?object} nextContext Next public object to set as context. |
| * @param {ReactReconcileTransaction} transaction |
| * @param {?object} unmaskedContext |
| * @private |
| */ |
| _performComponentUpdate: function (nextElement, nextProps, nextState, nextContext, transaction, unmaskedContext) { |
| var inst = this._instance; |
| |
| var hasComponentDidUpdate = Boolean(inst.componentDidUpdate); |
| var prevProps; |
| var prevState; |
| var prevContext; |
| if (hasComponentDidUpdate) { |
| prevProps = inst.props; |
| prevState = inst.state; |
| prevContext = inst.context; |
| } |
| |
| if (inst.componentWillUpdate) { |
| inst.componentWillUpdate(nextProps, nextState, nextContext); |
| } |
| |
| this._currentElement = nextElement; |
| this._context = unmaskedContext; |
| inst.props = nextProps; |
| inst.state = nextState; |
| inst.context = nextContext; |
| |
| this._updateRenderedComponent(transaction, unmaskedContext); |
| |
| if (hasComponentDidUpdate) { |
| transaction.getReactMountReady().enqueue(inst.componentDidUpdate.bind(inst, prevProps, prevState, prevContext), inst); |
| } |
| }, |
| |
| /** |
| * Call the component's `render` method and update the DOM accordingly. |
| * |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| */ |
| _updateRenderedComponent: function (transaction, context) { |
| var prevComponentInstance = this._renderedComponent; |
| var prevRenderedElement = prevComponentInstance._currentElement; |
| var nextRenderedElement = this._renderValidatedComponent(); |
| if (shouldUpdateReactComponent(prevRenderedElement, nextRenderedElement)) { |
| ReactReconciler.receiveComponent(prevComponentInstance, nextRenderedElement, transaction, this._processChildContext(context)); |
| } else { |
| // These two IDs are actually the same! But nothing should rely on that. |
| var thisID = this._rootNodeID; |
| var prevComponentID = prevComponentInstance._rootNodeID; |
| ReactReconciler.unmountComponent(prevComponentInstance); |
| |
| this._renderedComponent = this._instantiateReactComponent(nextRenderedElement); |
| var nextMarkup = ReactReconciler.mountComponent(this._renderedComponent, thisID, transaction, this._processChildContext(context)); |
| this._replaceNodeWithMarkupByID(prevComponentID, nextMarkup); |
| } |
| }, |
| |
| /** |
| * @protected |
| */ |
| _replaceNodeWithMarkupByID: function (prevComponentID, nextMarkup) { |
| ReactComponentEnvironment.replaceNodeWithMarkupByID(prevComponentID, nextMarkup); |
| }, |
| |
| /** |
| * @protected |
| */ |
| _renderValidatedComponentWithoutOwnerOrContext: function () { |
| var inst = this._instance; |
| var renderedComponent = inst.render(); |
| if ("development" !== 'production') { |
| // We allow auto-mocks to proceed as if they're returning null. |
| if (typeof renderedComponent === 'undefined' && inst.render._isMockFunction) { |
| // This is probably bad practice. Consider warning here and |
| // deprecating this convenience. |
| renderedComponent = null; |
| } |
| } |
| |
| return renderedComponent; |
| }, |
| |
| /** |
| * @private |
| */ |
| _renderValidatedComponent: function () { |
| var renderedComponent; |
| ReactCurrentOwner.current = this; |
| try { |
| renderedComponent = this._renderValidatedComponentWithoutOwnerOrContext(); |
| } finally { |
| ReactCurrentOwner.current = null; |
| } |
| !( |
| // TODO: An `isValidNode` function would probably be more appropriate |
| renderedComponent === null || renderedComponent === false || ReactElement.isValidElement(renderedComponent)) ? "development" !== 'production' ? invariant(false, '%s.render(): A valid ReactComponent must be returned. You may have ' + 'returned undefined, an array or some other invalid object.', this.getName() || 'ReactCompositeComponent') : invariant(false) : undefined; |
| return renderedComponent; |
| }, |
| |
| /** |
| * Lazily allocates the refs object and stores `component` as `ref`. |
| * |
| * @param {string} ref Reference name. |
| * @param {component} component Component to store as `ref`. |
| * @final |
| * @private |
| */ |
| attachRef: function (ref, component) { |
| var inst = this.getPublicInstance(); |
| !(inst != null) ? "development" !== 'production' ? invariant(false, 'Stateless function components cannot have refs.') : invariant(false) : undefined; |
| var publicComponentInstance = component.getPublicInstance(); |
| if ("development" !== 'production') { |
| var componentName = component && component.getName ? component.getName() : 'a component'; |
| "development" !== 'production' ? warning(publicComponentInstance != null, 'Stateless function components cannot be given refs ' + '(See ref "%s" in %s created by %s). ' + 'Attempts to access this ref will fail.', ref, componentName, this.getName()) : undefined; |
| } |
| var refs = inst.refs === emptyObject ? inst.refs = {} : inst.refs; |
| refs[ref] = publicComponentInstance; |
| }, |
| |
| /** |
| * Detaches a reference name. |
| * |
| * @param {string} ref Name to dereference. |
| * @final |
| * @private |
| */ |
| detachRef: function (ref) { |
| var refs = this.getPublicInstance().refs; |
| delete refs[ref]; |
| }, |
| |
| /** |
| * Get a text description of the component that can be used to identify it |
| * in error messages. |
| * @return {string} The name or null. |
| * @internal |
| */ |
| getName: function () { |
| var type = this._currentElement.type; |
| var constructor = this._instance && this._instance.constructor; |
| return type.displayName || constructor && constructor.displayName || type.name || constructor && constructor.name || null; |
| }, |
| |
| /** |
| * Get the publicly accessible representation of this component - i.e. what |
| * is exposed by refs and returned by render. Can be null for stateless |
| * components. |
| * |
| * @return {ReactComponent} the public component instance. |
| * @internal |
| */ |
| getPublicInstance: function () { |
| var inst = this._instance; |
| if (inst instanceof StatelessComponent) { |
| return null; |
| } |
| return inst; |
| }, |
| |
| // Stub |
| _instantiateReactComponent: null |
| |
| }; |
| |
| ReactPerf.measureMethods(ReactCompositeComponentMixin, 'ReactCompositeComponent', { |
| mountComponent: 'mountComponent', |
| updateComponent: 'updateComponent', |
| _renderValidatedComponent: '_renderValidatedComponent' |
| }); |
| |
| var ReactCompositeComponent = { |
| |
| Mixin: ReactCompositeComponentMixin |
| |
| }; |
| |
| module.exports = ReactCompositeComponent; |
| },{"141":141,"154":154,"161":161,"173":173,"24":24,"36":36,"39":39,"57":57,"68":68,"78":78,"80":80,"81":81,"84":84,"95":95}],39:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactCurrentOwner |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Keeps track of the current owner. |
| * |
| * The current owner is the component who should own any components that are |
| * currently being constructed. |
| */ |
| var ReactCurrentOwner = { |
| |
| /** |
| * @internal |
| * @type {ReactComponent} |
| */ |
| current: null |
| |
| }; |
| |
| module.exports = ReactCurrentOwner; |
| },{}],40:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOM |
| */ |
| |
| /* globals __REACT_DEVTOOLS_GLOBAL_HOOK__*/ |
| |
| 'use strict'; |
| |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactDOMTextComponent = _dereq_(51); |
| var ReactDefaultInjection = _dereq_(54); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactMount = _dereq_(72); |
| var ReactPerf = _dereq_(78); |
| var ReactReconciler = _dereq_(84); |
| var ReactUpdates = _dereq_(96); |
| var ReactVersion = _dereq_(97); |
| |
| var findDOMNode = _dereq_(122); |
| var renderSubtreeIntoContainer = _dereq_(137); |
| var warning = _dereq_(173); |
| |
| ReactDefaultInjection.inject(); |
| |
| var render = ReactPerf.measure('React', 'render', ReactMount.render); |
| |
| var React = { |
| findDOMNode: findDOMNode, |
| render: render, |
| unmountComponentAtNode: ReactMount.unmountComponentAtNode, |
| version: ReactVersion, |
| |
| /* eslint-disable camelcase */ |
| unstable_batchedUpdates: ReactUpdates.batchedUpdates, |
| unstable_renderSubtreeIntoContainer: renderSubtreeIntoContainer |
| }; |
| |
| // Inject the runtime into a devtools global hook regardless of browser. |
| // Allows for debugging when the hook is injected on the page. |
| /* eslint-enable camelcase */ |
| if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined' && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.inject === 'function') { |
| __REACT_DEVTOOLS_GLOBAL_HOOK__.inject({ |
| CurrentOwner: ReactCurrentOwner, |
| InstanceHandles: ReactInstanceHandles, |
| Mount: ReactMount, |
| Reconciler: ReactReconciler, |
| TextComponent: ReactDOMTextComponent |
| }); |
| } |
| |
| if ("development" !== 'production') { |
| var ExecutionEnvironment = _dereq_(147); |
| if (ExecutionEnvironment.canUseDOM && window.top === window.self) { |
| |
| // First check if devtools is not installed |
| if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') { |
| // If we're in Chrome or Firefox, provide a download link if not installed. |
| if (navigator.userAgent.indexOf('Chrome') > -1 && navigator.userAgent.indexOf('Edge') === -1 || navigator.userAgent.indexOf('Firefox') > -1) { |
| console.debug('Download the React DevTools for a better development experience: ' + 'https://fb.me/react-devtools'); |
| } |
| } |
| |
| // If we're in IE8, check to see if we are in compatibility mode and provide |
| // information on preventing compatibility mode |
| var ieCompatibilityMode = document.documentMode && document.documentMode < 8; |
| |
| "development" !== 'production' ? warning(!ieCompatibilityMode, 'Internet Explorer is running in compatibility mode; please add the ' + 'following tag to your HTML to prevent this from happening: ' + '<meta http-equiv="X-UA-Compatible" content="IE=edge" />') : undefined; |
| |
| var expectedFeatures = [ |
| // shims |
| Array.isArray, Array.prototype.every, Array.prototype.forEach, Array.prototype.indexOf, Array.prototype.map, Date.now, Function.prototype.bind, Object.keys, String.prototype.split, String.prototype.trim, |
| |
| // shams |
| Object.create, Object.freeze]; |
| |
| for (var i = 0; i < expectedFeatures.length; i++) { |
| if (!expectedFeatures[i]) { |
| console.error('One or more ES5 shim/shams expected by React are not available: ' + 'https://fb.me/react-warning-polyfills'); |
| break; |
| } |
| } |
| } |
| } |
| |
| module.exports = React; |
| },{"122":122,"137":137,"147":147,"173":173,"39":39,"51":51,"54":54,"67":67,"72":72,"78":78,"84":84,"96":96,"97":97}],41:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMButton |
| */ |
| |
| 'use strict'; |
| |
| var mouseListenerNames = { |
| onClick: true, |
| onDoubleClick: true, |
| onMouseDown: true, |
| onMouseMove: true, |
| onMouseUp: true, |
| |
| onClickCapture: true, |
| onDoubleClickCapture: true, |
| onMouseDownCapture: true, |
| onMouseMoveCapture: true, |
| onMouseUpCapture: true |
| }; |
| |
| /** |
| * Implements a <button> native component that does not receive mouse events |
| * when `disabled` is set. |
| */ |
| var ReactDOMButton = { |
| getNativeProps: function (inst, props, context) { |
| if (!props.disabled) { |
| return props; |
| } |
| |
| // Copy the props, except the mouse listeners |
| var nativeProps = {}; |
| for (var key in props) { |
| if (props.hasOwnProperty(key) && !mouseListenerNames[key]) { |
| nativeProps[key] = props[key]; |
| } |
| } |
| |
| return nativeProps; |
| } |
| }; |
| |
| module.exports = ReactDOMButton; |
| },{}],42:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMComponent |
| * @typechecks static-only |
| */ |
| |
| /* global hasOwnProperty:true */ |
| |
| 'use strict'; |
| |
| var AutoFocusUtils = _dereq_(2); |
| var CSSPropertyOperations = _dereq_(5); |
| var DOMProperty = _dereq_(10); |
| var DOMPropertyOperations = _dereq_(11); |
| var EventConstants = _dereq_(15); |
| var ReactBrowserEventEmitter = _dereq_(28); |
| var ReactComponentBrowserEnvironment = _dereq_(35); |
| var ReactDOMButton = _dereq_(41); |
| var ReactDOMInput = _dereq_(46); |
| var ReactDOMOption = _dereq_(47); |
| var ReactDOMSelect = _dereq_(48); |
| var ReactDOMTextarea = _dereq_(52); |
| var ReactMount = _dereq_(72); |
| var ReactMultiChild = _dereq_(73); |
| var ReactPerf = _dereq_(78); |
| var ReactUpdateQueue = _dereq_(95); |
| |
| var assign = _dereq_(24); |
| var canDefineProperty = _dereq_(117); |
| var escapeTextContentForBrowser = _dereq_(121); |
| var invariant = _dereq_(161); |
| var isEventSupported = _dereq_(133); |
| var keyOf = _dereq_(166); |
| var setInnerHTML = _dereq_(138); |
| var setTextContent = _dereq_(139); |
| var shallowEqual = _dereq_(171); |
| var validateDOMNesting = _dereq_(144); |
| var warning = _dereq_(173); |
| |
| var deleteListener = ReactBrowserEventEmitter.deleteListener; |
| var listenTo = ReactBrowserEventEmitter.listenTo; |
| var registrationNameModules = ReactBrowserEventEmitter.registrationNameModules; |
| |
| // For quickly matching children type, to test if can be treated as content. |
| var CONTENT_TYPES = { 'string': true, 'number': true }; |
| |
| var STYLE = keyOf({ style: null }); |
| var HTML = keyOf({ __html: null }); |
| |
| var ELEMENT_NODE_TYPE = 1; |
| |
| function getDeclarationErrorAddendum(internalInstance) { |
| if (internalInstance) { |
| var owner = internalInstance._currentElement._owner || null; |
| if (owner) { |
| var name = owner.getName(); |
| if (name) { |
| return ' This DOM node was rendered by `' + name + '`.'; |
| } |
| } |
| } |
| return ''; |
| } |
| |
| var legacyPropsDescriptor; |
| if ("development" !== 'production') { |
| legacyPropsDescriptor = { |
| props: { |
| enumerable: false, |
| get: function () { |
| var component = this._reactInternalComponent; |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .props of a DOM node; instead, ' + 'recreate the props as `render` did originally or read the DOM ' + 'properties/attributes directly from this node (e.g., ' + 'this.refs.box.className).%s', getDeclarationErrorAddendum(component)) : undefined; |
| return component._currentElement.props; |
| } |
| } |
| }; |
| } |
| |
| function legacyGetDOMNode() { |
| if ("development" !== 'production') { |
| var component = this._reactInternalComponent; |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .getDOMNode() of a DOM node; ' + 'instead, use the node directly.%s', getDeclarationErrorAddendum(component)) : undefined; |
| } |
| return this; |
| } |
| |
| function legacyIsMounted() { |
| var component = this._reactInternalComponent; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .isMounted() of a DOM node.%s', getDeclarationErrorAddendum(component)) : undefined; |
| } |
| return !!component; |
| } |
| |
| function legacySetStateEtc() { |
| if ("development" !== 'production') { |
| var component = this._reactInternalComponent; |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .setState(), .replaceState(), or ' + '.forceUpdate() of a DOM node. This is a no-op.%s', getDeclarationErrorAddendum(component)) : undefined; |
| } |
| } |
| |
| function legacySetProps(partialProps, callback) { |
| var component = this._reactInternalComponent; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .setProps() of a DOM node. ' + 'Instead, call ReactDOM.render again at the top level.%s', getDeclarationErrorAddendum(component)) : undefined; |
| } |
| if (!component) { |
| return; |
| } |
| ReactUpdateQueue.enqueueSetPropsInternal(component, partialProps); |
| if (callback) { |
| ReactUpdateQueue.enqueueCallbackInternal(component, callback); |
| } |
| } |
| |
| function legacyReplaceProps(partialProps, callback) { |
| var component = this._reactInternalComponent; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, 'ReactDOMComponent: Do not access .replaceProps() of a DOM node. ' + 'Instead, call ReactDOM.render again at the top level.%s', getDeclarationErrorAddendum(component)) : undefined; |
| } |
| if (!component) { |
| return; |
| } |
| ReactUpdateQueue.enqueueReplacePropsInternal(component, partialProps); |
| if (callback) { |
| ReactUpdateQueue.enqueueCallbackInternal(component, callback); |
| } |
| } |
| |
| function friendlyStringify(obj) { |
| if (typeof obj === 'object') { |
| if (Array.isArray(obj)) { |
| return '[' + obj.map(friendlyStringify).join(', ') + ']'; |
| } else { |
| var pairs = []; |
| for (var key in obj) { |
| if (Object.prototype.hasOwnProperty.call(obj, key)) { |
| var keyEscaped = /^[a-z$_][\w$_]*$/i.test(key) ? key : JSON.stringify(key); |
| pairs.push(keyEscaped + ': ' + friendlyStringify(obj[key])); |
| } |
| } |
| return '{' + pairs.join(', ') + '}'; |
| } |
| } else if (typeof obj === 'string') { |
| return JSON.stringify(obj); |
| } else if (typeof obj === 'function') { |
| return '[function object]'; |
| } |
| // Differs from JSON.stringify in that undefined becauses undefined and that |
| // inf and nan don't become null |
| return String(obj); |
| } |
| |
| var styleMutationWarning = {}; |
| |
| function checkAndWarnForMutatedStyle(style1, style2, component) { |
| if (style1 == null || style2 == null) { |
| return; |
| } |
| if (shallowEqual(style1, style2)) { |
| return; |
| } |
| |
| var componentName = component._tag; |
| var owner = component._currentElement._owner; |
| var ownerName; |
| if (owner) { |
| ownerName = owner.getName(); |
| } |
| |
| var hash = ownerName + '|' + componentName; |
| |
| if (styleMutationWarning.hasOwnProperty(hash)) { |
| return; |
| } |
| |
| styleMutationWarning[hash] = true; |
| |
| "development" !== 'production' ? warning(false, '`%s` was passed a style object that has previously been mutated. ' + 'Mutating `style` is deprecated. Consider cloning it beforehand. Check ' + 'the `render` %s. Previous style: %s. Mutated style: %s.', componentName, owner ? 'of `' + ownerName + '`' : 'using <' + componentName + '>', friendlyStringify(style1), friendlyStringify(style2)) : undefined; |
| } |
| |
| /** |
| * @param {object} component |
| * @param {?object} props |
| */ |
| function assertValidProps(component, props) { |
| if (!props) { |
| return; |
| } |
| // Note the use of `==` which checks for null or undefined. |
| if ("development" !== 'production') { |
| if (voidElementTags[component._tag]) { |
| "development" !== 'production' ? warning(props.children == null && props.dangerouslySetInnerHTML == null, '%s is a void element tag and must not have `children` or ' + 'use `props.dangerouslySetInnerHTML`.%s', component._tag, component._currentElement._owner ? ' Check the render method of ' + component._currentElement._owner.getName() + '.' : '') : undefined; |
| } |
| } |
| if (props.dangerouslySetInnerHTML != null) { |
| !(props.children == null) ? "development" !== 'production' ? invariant(false, 'Can only set one of `children` or `props.dangerouslySetInnerHTML`.') : invariant(false) : undefined; |
| !(typeof props.dangerouslySetInnerHTML === 'object' && HTML in props.dangerouslySetInnerHTML) ? "development" !== '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.') : invariant(false) : undefined; |
| } |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(props.innerHTML == null, 'Directly setting property `innerHTML` is not permitted. ' + 'For more information, lookup documentation on `dangerouslySetInnerHTML`.') : undefined; |
| "development" !== 'production' ? warning(!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.') : undefined; |
| } |
| !(props.style == null || typeof props.style === 'object') ? "development" !== '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)) : invariant(false) : undefined; |
| } |
| |
| function enqueuePutListener(id, registrationName, listener, transaction) { |
| if ("development" !== 'production') { |
| // IE8 has no API for event capturing and the `onScroll` event doesn't |
| // bubble. |
| "development" !== 'production' ? warning(registrationName !== 'onScroll' || isEventSupported('scroll', true), 'This browser doesn\'t support the `onScroll` event') : undefined; |
| } |
| var container = ReactMount.findReactContainerForID(id); |
| if (container) { |
| var doc = container.nodeType === ELEMENT_NODE_TYPE ? container.ownerDocument : container; |
| listenTo(registrationName, doc); |
| } |
| transaction.getReactMountReady().enqueue(putListener, { |
| id: id, |
| registrationName: registrationName, |
| listener: listener |
| }); |
| } |
| |
| function putListener() { |
| var listenerToPut = this; |
| ReactBrowserEventEmitter.putListener(listenerToPut.id, listenerToPut.registrationName, listenerToPut.listener); |
| } |
| |
| // There are so many media events, it makes sense to just |
| // maintain a list rather than create a `trapBubbledEvent` for each |
| var mediaEvents = { |
| topAbort: 'abort', |
| topCanPlay: 'canplay', |
| topCanPlayThrough: 'canplaythrough', |
| topDurationChange: 'durationchange', |
| topEmptied: 'emptied', |
| topEncrypted: 'encrypted', |
| topEnded: 'ended', |
| topError: 'error', |
| topLoadedData: 'loadeddata', |
| topLoadedMetadata: 'loadedmetadata', |
| topLoadStart: 'loadstart', |
| topPause: 'pause', |
| topPlay: 'play', |
| topPlaying: 'playing', |
| topProgress: 'progress', |
| topRateChange: 'ratechange', |
| topSeeked: 'seeked', |
| topSeeking: 'seeking', |
| topStalled: 'stalled', |
| topSuspend: 'suspend', |
| topTimeUpdate: 'timeupdate', |
| topVolumeChange: 'volumechange', |
| topWaiting: 'waiting' |
| }; |
| |
| function trapBubbledEventsLocal() { |
| var inst = this; |
| // If a component renders to null or if another component fatals and causes |
| // the state of the tree to be corrupted, `node` here can be null. |
| !inst._rootNodeID ? "development" !== 'production' ? invariant(false, 'Must be mounted to trap events') : invariant(false) : undefined; |
| var node = ReactMount.getNode(inst._rootNodeID); |
| !node ? "development" !== 'production' ? invariant(false, 'trapBubbledEvent(...): Requires node to be rendered.') : invariant(false) : undefined; |
| |
| switch (inst._tag) { |
| case 'iframe': |
| inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load', node)]; |
| break; |
| case 'video': |
| case 'audio': |
| |
| inst._wrapperState.listeners = []; |
| // create listener for each media event |
| for (var event in mediaEvents) { |
| if (mediaEvents.hasOwnProperty(event)) { |
| inst._wrapperState.listeners.push(ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes[event], mediaEvents[event], node)); |
| } |
| } |
| |
| break; |
| case 'img': |
| inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topError, 'error', node), ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topLoad, 'load', node)]; |
| break; |
| case 'form': |
| inst._wrapperState.listeners = [ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topReset, 'reset', node), ReactBrowserEventEmitter.trapBubbledEvent(EventConstants.topLevelTypes.topSubmit, 'submit', node)]; |
| break; |
| } |
| } |
| |
| function mountReadyInputWrapper() { |
| ReactDOMInput.mountReadyWrapper(this); |
| } |
| |
| function postUpdateSelectWrapper() { |
| ReactDOMSelect.postUpdateWrapper(this); |
| } |
| |
| // For HTML, certain tags should omit their close tag. We keep a whitelist for |
| // those special cased tags. |
| |
| var omittedCloseTags = { |
| 'area': true, |
| 'base': true, |
| 'br': true, |
| 'col': true, |
| 'embed': true, |
| 'hr': true, |
| 'img': true, |
| 'input': true, |
| 'keygen': true, |
| 'link': true, |
| 'meta': true, |
| 'param': true, |
| 'source': true, |
| 'track': true, |
| 'wbr': true |
| }; |
| |
| // NOTE: menuitem's close tag should be omitted, but that causes problems. |
| var newlineEatingTags = { |
| 'listing': true, |
| 'pre': true, |
| 'textarea': true |
| }; |
| |
| // For HTML, certain tags cannot have children. This has the same purpose as |
| // `omittedCloseTags` except that `menuitem` should still have its closing tag. |
| |
| var voidElementTags = assign({ |
| 'menuitem': true |
| }, omittedCloseTags); |
| |
| // We accept any tag to be rendered but since this gets injected into arbitrary |
| // HTML, we want to make sure that it's a safe tag. |
| // http://www.w3.org/TR/REC-xml/#NT-Name |
| |
| var VALID_TAG_REGEX = /^[a-zA-Z][a-zA-Z:_\.\-\d]*$/; // Simplified subset |
| var validatedTagCache = {}; |
| var hasOwnProperty = ({}).hasOwnProperty; |
| |
| function validateDangerousTag(tag) { |
| if (!hasOwnProperty.call(validatedTagCache, tag)) { |
| !VALID_TAG_REGEX.test(tag) ? "development" !== 'production' ? invariant(false, 'Invalid tag: %s', tag) : invariant(false) : undefined; |
| validatedTagCache[tag] = true; |
| } |
| } |
| |
| function processChildContextDev(context, inst) { |
| // Pass down our tag name to child components for validation purposes |
| context = assign({}, context); |
| var info = context[validateDOMNesting.ancestorInfoContextKey]; |
| context[validateDOMNesting.ancestorInfoContextKey] = validateDOMNesting.updatedAncestorInfo(info, inst._tag, inst); |
| return context; |
| } |
| |
| function isCustomComponent(tagName, props) { |
| return tagName.indexOf('-') >= 0 || props.is != 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 |
| */ |
| function ReactDOMComponent(tag) { |
| validateDangerousTag(tag); |
| this._tag = tag.toLowerCase(); |
| this._renderedChildren = null; |
| this._previousStyle = null; |
| this._previousStyleCopy = null; |
| this._rootNodeID = null; |
| this._wrapperState = null; |
| this._topLevelWrapper = null; |
| this._nodeWithLegacyProperties = null; |
| if ("development" !== 'production') { |
| this._unprocessedContextDev = null; |
| this._processedContextDev = null; |
| } |
| } |
| |
| ReactDOMComponent.displayName = 'ReactDOMComponent'; |
| |
| ReactDOMComponent.Mixin = { |
| |
| construct: function (element) { |
| this._currentElement = element; |
| }, |
| |
| /** |
| * Generates root tag markup then recurses. This method has side effects and |
| * is not idempotent. |
| * |
| * @internal |
| * @param {string} rootID The root DOM ID for this node. |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @param {object} context |
| * @return {string} The computed markup. |
| */ |
| mountComponent: function (rootID, transaction, context) { |
| this._rootNodeID = rootID; |
| |
| var props = this._currentElement.props; |
| |
| switch (this._tag) { |
| case 'iframe': |
| case 'img': |
| case 'form': |
| case 'video': |
| case 'audio': |
| this._wrapperState = { |
| listeners: null |
| }; |
| transaction.getReactMountReady().enqueue(trapBubbledEventsLocal, this); |
| break; |
| case 'button': |
| props = ReactDOMButton.getNativeProps(this, props, context); |
| break; |
| case 'input': |
| ReactDOMInput.mountWrapper(this, props, context); |
| props = ReactDOMInput.getNativeProps(this, props, context); |
| break; |
| case 'option': |
| ReactDOMOption.mountWrapper(this, props, context); |
| props = ReactDOMOption.getNativeProps(this, props, context); |
| break; |
| case 'select': |
| ReactDOMSelect.mountWrapper(this, props, context); |
| props = ReactDOMSelect.getNativeProps(this, props, context); |
| context = ReactDOMSelect.processChildContext(this, props, context); |
| break; |
| case 'textarea': |
| ReactDOMTextarea.mountWrapper(this, props, context); |
| props = ReactDOMTextarea.getNativeProps(this, props, context); |
| break; |
| } |
| |
| assertValidProps(this, props); |
| if ("development" !== 'production') { |
| if (context[validateDOMNesting.ancestorInfoContextKey]) { |
| validateDOMNesting(this._tag, this, context[validateDOMNesting.ancestorInfoContextKey]); |
| } |
| } |
| |
| if ("development" !== 'production') { |
| this._unprocessedContextDev = context; |
| this._processedContextDev = processChildContextDev(context, this); |
| context = this._processedContextDev; |
| } |
| |
| var mountImage; |
| if (transaction.useCreateElement) { |
| var ownerDocument = context[ReactMount.ownerDocumentContextKey]; |
| var el = ownerDocument.createElement(this._currentElement.type); |
| DOMPropertyOperations.setAttributeForID(el, this._rootNodeID); |
| // Populate node cache |
| ReactMount.getID(el); |
| this._updateDOMProperties({}, props, transaction, el); |
| this._createInitialChildren(transaction, props, context, el); |
| mountImage = el; |
| } else { |
| var tagOpen = this._createOpenTagMarkupAndPutListeners(transaction, props); |
| var tagContent = this._createContentMarkup(transaction, props, context); |
| if (!tagContent && omittedCloseTags[this._tag]) { |
| mountImage = tagOpen + '/>'; |
| } else { |
| mountImage = tagOpen + '>' + tagContent + '</' + this._currentElement.type + '>'; |
| } |
| } |
| |
| switch (this._tag) { |
| case 'input': |
| transaction.getReactMountReady().enqueue(mountReadyInputWrapper, this); |
| // falls through |
| case 'button': |
| case 'select': |
| case 'textarea': |
| if (props.autoFocus) { |
| transaction.getReactMountReady().enqueue(AutoFocusUtils.focusDOMComponent, this); |
| } |
| break; |
| } |
| |
| return mountImage; |
| }, |
| |
| /** |
| * Creates markup for the open tag and all attributes. |
| * |
| * This method has side effects because events get registered. |
| * |
| * Iterating over object properties is faster than iterating over arrays. |
| * @see http://jsperf.com/obj-vs-arr-iteration |
| * |
| * @private |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @param {object} props |
| * @return {string} Markup of opening tag. |
| */ |
| _createOpenTagMarkupAndPutListeners: function (transaction, props) { |
| var ret = '<' + this._currentElement.type; |
| |
| for (var propKey in props) { |
| if (!props.hasOwnProperty(propKey)) { |
| continue; |
| } |
| var propValue = props[propKey]; |
| if (propValue == null) { |
| continue; |
| } |
| if (registrationNameModules.hasOwnProperty(propKey)) { |
| if (propValue) { |
| enqueuePutListener(this._rootNodeID, propKey, propValue, transaction); |
| } |
| } else { |
| if (propKey === STYLE) { |
| if (propValue) { |
| if ("development" !== 'production') { |
| // See `_updateDOMProperties`. style block |
| this._previousStyle = propValue; |
| } |
| propValue = this._previousStyleCopy = assign({}, props.style); |
| } |
| propValue = CSSPropertyOperations.createMarkupForStyles(propValue); |
| } |
| var markup = null; |
| if (this._tag != null && isCustomComponent(this._tag, props)) { |
| markup = DOMPropertyOperations.createMarkupForCustomAttribute(propKey, propValue); |
| } else { |
| markup = DOMPropertyOperations.createMarkupForProperty(propKey, propValue); |
| } |
| if (markup) { |
| ret += ' ' + markup; |
| } |
| } |
| } |
| |
| // For static pages, no need to put React ID and checksum. Saves lots of |
| // bytes. |
| if (transaction.renderToStaticMarkup) { |
| return ret; |
| } |
| |
| var markupForID = DOMPropertyOperations.createMarkupForID(this._rootNodeID); |
| return ret + ' ' + markupForID; |
| }, |
| |
| /** |
| * Creates markup for the content between the tags. |
| * |
| * @private |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @param {object} props |
| * @param {object} context |
| * @return {string} Content markup. |
| */ |
| _createContentMarkup: function (transaction, props, context) { |
| var ret = ''; |
| |
| // Intentional use of != to avoid catching zero/false. |
| var innerHTML = props.dangerouslySetInnerHTML; |
| if (innerHTML != null) { |
| if (innerHTML.__html != null) { |
| ret = innerHTML.__html; |
| } |
| } else { |
| var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null; |
| var childrenToUse = contentToUse != null ? null : props.children; |
| if (contentToUse != null) { |
| // TODO: Validate that text is allowed as a child of this node |
| ret = escapeTextContentForBrowser(contentToUse); |
| } else if (childrenToUse != null) { |
| var mountImages = this.mountChildren(childrenToUse, transaction, context); |
| ret = mountImages.join(''); |
| } |
| } |
| if (newlineEatingTags[this._tag] && ret.charAt(0) === '\n') { |
| // text/html ignores the first character in these tags if it's a newline |
| // Prefer to break application/xml over text/html (for now) by adding |
| // a newline specifically to get eaten by the parser. (Alternately for |
| // textareas, replacing "^\n" with "\r\n" doesn't get eaten, and the first |
| // \r is normalized out by HTMLTextAreaElement#value.) |
| // See: <http://www.w3.org/TR/html-polyglot/#newlines-in-textarea-and-pre> |
| // See: <http://www.w3.org/TR/html5/syntax.html#element-restrictions> |
| // See: <http://www.w3.org/TR/html5/syntax.html#newlines> |
| // See: Parsing of "textarea" "listing" and "pre" elements |
| // from <http://www.w3.org/TR/html5/syntax.html#parsing-main-inbody> |
| return '\n' + ret; |
| } else { |
| return ret; |
| } |
| }, |
| |
| _createInitialChildren: function (transaction, props, context, el) { |
| // Intentional use of != to avoid catching zero/false. |
| var innerHTML = props.dangerouslySetInnerHTML; |
| if (innerHTML != null) { |
| if (innerHTML.__html != null) { |
| setInnerHTML(el, innerHTML.__html); |
| } |
| } else { |
| var contentToUse = CONTENT_TYPES[typeof props.children] ? props.children : null; |
| var childrenToUse = contentToUse != null ? null : props.children; |
| if (contentToUse != null) { |
| // TODO: Validate that text is allowed as a child of this node |
| setTextContent(el, contentToUse); |
| } else if (childrenToUse != null) { |
| var mountImages = this.mountChildren(childrenToUse, transaction, context); |
| for (var i = 0; i < mountImages.length; i++) { |
| el.appendChild(mountImages[i]); |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Receives a next element and updates the component. |
| * |
| * @internal |
| * @param {ReactElement} nextElement |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @param {object} context |
| */ |
| receiveComponent: function (nextElement, transaction, context) { |
| var prevElement = this._currentElement; |
| this._currentElement = nextElement; |
| this.updateComponent(transaction, prevElement, nextElement, context); |
| }, |
| |
| /** |
| * Updates a native DOM component after it has already been allocated and |
| * attached to the DOM. Reconciles the root DOM node, then recurses. |
| * |
| * @param {ReactReconcileTransaction} transaction |
| * @param {ReactElement} prevElement |
| * @param {ReactElement} nextElement |
| * @internal |
| * @overridable |
| */ |
| updateComponent: function (transaction, prevElement, nextElement, context) { |
| var lastProps = prevElement.props; |
| var nextProps = this._currentElement.props; |
| |
| switch (this._tag) { |
| case 'button': |
| lastProps = ReactDOMButton.getNativeProps(this, lastProps); |
| nextProps = ReactDOMButton.getNativeProps(this, nextProps); |
| break; |
| case 'input': |
| ReactDOMInput.updateWrapper(this); |
| lastProps = ReactDOMInput.getNativeProps(this, lastProps); |
| nextProps = ReactDOMInput.getNativeProps(this, nextProps); |
| break; |
| case 'option': |
| lastProps = ReactDOMOption.getNativeProps(this, lastProps); |
| nextProps = ReactDOMOption.getNativeProps(this, nextProps); |
| break; |
| case 'select': |
| lastProps = ReactDOMSelect.getNativeProps(this, lastProps); |
| nextProps = ReactDOMSelect.getNativeProps(this, nextProps); |
| break; |
| case 'textarea': |
| ReactDOMTextarea.updateWrapper(this); |
| lastProps = ReactDOMTextarea.getNativeProps(this, lastProps); |
| nextProps = ReactDOMTextarea.getNativeProps(this, nextProps); |
| break; |
| } |
| |
| if ("development" !== 'production') { |
| // If the context is reference-equal to the old one, pass down the same |
| // processed object so the update bailout in ReactReconciler behaves |
| // correctly (and identically in dev and prod). See #5005. |
| if (this._unprocessedContextDev !== context) { |
| this._unprocessedContextDev = context; |
| this._processedContextDev = processChildContextDev(context, this); |
| } |
| context = this._processedContextDev; |
| } |
| |
| assertValidProps(this, nextProps); |
| this._updateDOMProperties(lastProps, nextProps, transaction, null); |
| this._updateDOMChildren(lastProps, nextProps, transaction, context); |
| |
| if (!canDefineProperty && this._nodeWithLegacyProperties) { |
| this._nodeWithLegacyProperties.props = nextProps; |
| } |
| |
| if (this._tag === 'select') { |
| // <select> value update needs to occur after <option> children |
| // reconciliation |
| transaction.getReactMountReady().enqueue(postUpdateSelectWrapper, this); |
| } |
| }, |
| |
| /** |
| * Reconciles the properties by detecting differences in property values and |
| * updating the DOM as necessary. This function is probably the single most |
| * critical path for performance optimization. |
| * |
| * TODO: Benchmark whether checking for changed values in memory actually |
| * improves performance (especially statically positioned elements). |
| * TODO: Benchmark the effects of putting this at the top since 99% of props |
| * do not change for a given reconciliation. |
| * TODO: Benchmark areas that can be improved with caching. |
| * |
| * @private |
| * @param {object} lastProps |
| * @param {object} nextProps |
| * @param {ReactReconcileTransaction} transaction |
| * @param {?DOMElement} node |
| */ |
| _updateDOMProperties: function (lastProps, nextProps, transaction, node) { |
| var propKey; |
| var styleName; |
| var styleUpdates; |
| for (propKey in lastProps) { |
| if (nextProps.hasOwnProperty(propKey) || !lastProps.hasOwnProperty(propKey)) { |
| continue; |
| } |
| if (propKey === STYLE) { |
| var lastStyle = this._previousStyleCopy; |
| for (styleName in lastStyle) { |
| if (lastStyle.hasOwnProperty(styleName)) { |
| styleUpdates = styleUpdates || {}; |
| styleUpdates[styleName] = ''; |
| } |
| } |
| this._previousStyleCopy = null; |
| } else if (registrationNameModules.hasOwnProperty(propKey)) { |
| if (lastProps[propKey]) { |
| // Only call deleteListener if there was a listener previously or |
| // else willDeleteListener gets called when there wasn't actually a |
| // listener (e.g., onClick={null}) |
| deleteListener(this._rootNodeID, propKey); |
| } |
| } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) { |
| if (!node) { |
| node = ReactMount.getNode(this._rootNodeID); |
| } |
| DOMPropertyOperations.deleteValueForProperty(node, propKey); |
| } |
| } |
| for (propKey in nextProps) { |
| var nextProp = nextProps[propKey]; |
| var lastProp = propKey === STYLE ? this._previousStyleCopy : lastProps[propKey]; |
| if (!nextProps.hasOwnProperty(propKey) || nextProp === lastProp) { |
| continue; |
| } |
| if (propKey === STYLE) { |
| if (nextProp) { |
| if ("development" !== 'production') { |
| checkAndWarnForMutatedStyle(this._previousStyleCopy, this._previousStyle, this); |
| this._previousStyle = nextProp; |
| } |
| nextProp = this._previousStyleCopy = assign({}, nextProp); |
| } else { |
| this._previousStyleCopy = null; |
| } |
| if (lastProp) { |
| // Unset styles on `lastProp` but not on `nextProp`. |
| for (styleName in lastProp) { |
| if (lastProp.hasOwnProperty(styleName) && (!nextProp || !nextProp.hasOwnProperty(styleName))) { |
| styleUpdates = styleUpdates || {}; |
| styleUpdates[styleName] = ''; |
| } |
| } |
| // Update styles that changed since `lastProp`. |
| for (styleName in nextProp) { |
| if (nextProp.hasOwnProperty(styleName) && lastProp[styleName] !== nextProp[styleName]) { |
| styleUpdates = styleUpdates || {}; |
| styleUpdates[styleName] = nextProp[styleName]; |
| } |
| } |
| } else { |
| // Relies on `updateStylesByID` not mutating `styleUpdates`. |
| styleUpdates = nextProp; |
| } |
| } else if (registrationNameModules.hasOwnProperty(propKey)) { |
| if (nextProp) { |
| enqueuePutListener(this._rootNodeID, propKey, nextProp, transaction); |
| } else if (lastProp) { |
| deleteListener(this._rootNodeID, propKey); |
| } |
| } else if (isCustomComponent(this._tag, nextProps)) { |
| if (!node) { |
| node = ReactMount.getNode(this._rootNodeID); |
| } |
| DOMPropertyOperations.setValueForAttribute(node, propKey, nextProp); |
| } else if (DOMProperty.properties[propKey] || DOMProperty.isCustomAttribute(propKey)) { |
| if (!node) { |
| node = ReactMount.getNode(this._rootNodeID); |
| } |
| // If we're updating to null or undefined, we should remove the property |
| // from the DOM node instead of inadvertantly setting to a string. This |
| // brings us in line with the same behavior we have on initial render. |
| if (nextProp != null) { |
| DOMPropertyOperations.setValueForProperty(node, propKey, nextProp); |
| } else { |
| DOMPropertyOperations.deleteValueForProperty(node, propKey); |
| } |
| } |
| } |
| if (styleUpdates) { |
| if (!node) { |
| node = ReactMount.getNode(this._rootNodeID); |
| } |
| CSSPropertyOperations.setValueForStyles(node, styleUpdates); |
| } |
| }, |
| |
| /** |
| * Reconciles the children with the various properties that affect the |
| * children content. |
| * |
| * @param {object} lastProps |
| * @param {object} nextProps |
| * @param {ReactReconcileTransaction} transaction |
| * @param {object} context |
| */ |
| _updateDOMChildren: function (lastProps, nextProps, transaction, context) { |
| var lastContent = CONTENT_TYPES[typeof lastProps.children] ? lastProps.children : null; |
| var nextContent = CONTENT_TYPES[typeof nextProps.children] ? nextProps.children : null; |
| |
| var lastHtml = lastProps.dangerouslySetInnerHTML && lastProps.dangerouslySetInnerHTML.__html; |
| var nextHtml = nextProps.dangerouslySetInnerHTML && nextProps.dangerouslySetInnerHTML.__html; |
| |
| // Note the use of `!=` which checks for null or undefined. |
| var lastChildren = lastContent != null ? null : lastProps.children; |
| var nextChildren = nextContent != null ? null : nextProps.children; |
| |
| // If we're switching from children to content/html or vice versa, remove |
| // the old content |
| var lastHasContentOrHtml = lastContent != null || lastHtml != null; |
| var nextHasContentOrHtml = nextContent != null || nextHtml != null; |
| if (lastChildren != null && nextChildren == null) { |
| this.updateChildren(null, transaction, context); |
| } else if (lastHasContentOrHtml && !nextHasContentOrHtml) { |
| this.updateTextContent(''); |
| } |
| |
| if (nextContent != null) { |
| if (lastContent !== nextContent) { |
| this.updateTextContent('' + nextContent); |
| } |
| } else if (nextHtml != null) { |
| if (lastHtml !== nextHtml) { |
| this.updateMarkup('' + nextHtml); |
| } |
| } else if (nextChildren != null) { |
| this.updateChildren(nextChildren, transaction, context); |
| } |
| }, |
| |
| /** |
| * Destroys all event registrations for this instance. Does not remove from |
| * the DOM. That must be done by the parent. |
| * |
| * @internal |
| */ |
| unmountComponent: function () { |
| switch (this._tag) { |
| case 'iframe': |
| case 'img': |
| case 'form': |
| case 'video': |
| case 'audio': |
| var listeners = this._wrapperState.listeners; |
| if (listeners) { |
| for (var i = 0; i < listeners.length; i++) { |
| listeners[i].remove(); |
| } |
| } |
| break; |
| case 'input': |
| ReactDOMInput.unmountWrapper(this); |
| break; |
| case 'html': |
| case 'head': |
| case 'body': |
| /** |
| * Components like <html> <head> and <body> can't be removed or added |
| * easily in a cross-browser way, however it's valuable to be able to |
| * take advantage of React's reconciliation for styling and <title> |
| * management. So we just document it and throw in dangerous cases. |
| */ |
| !false ? "development" !== 'production' ? invariant(false, '<%s> tried to unmount. Because of cross-browser quirks it is ' + 'impossible to unmount some top-level components (eg <html>, ' + '<head>, and <body>) reliably and efficiently. To fix this, have a ' + 'single top-level component that never unmounts render these ' + 'elements.', this._tag) : invariant(false) : undefined; |
| break; |
| } |
| |
| this.unmountChildren(); |
| ReactBrowserEventEmitter.deleteAllListeners(this._rootNodeID); |
| ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID); |
| this._rootNodeID = null; |
| this._wrapperState = null; |
| if (this._nodeWithLegacyProperties) { |
| var node = this._nodeWithLegacyProperties; |
| node._reactInternalComponent = null; |
| this._nodeWithLegacyProperties = null; |
| } |
| }, |
| |
| getPublicInstance: function () { |
| if (!this._nodeWithLegacyProperties) { |
| var node = ReactMount.getNode(this._rootNodeID); |
| |
| node._reactInternalComponent = this; |
| node.getDOMNode = legacyGetDOMNode; |
| node.isMounted = legacyIsMounted; |
| node.setState = legacySetStateEtc; |
| node.replaceState = legacySetStateEtc; |
| node.forceUpdate = legacySetStateEtc; |
| node.setProps = legacySetProps; |
| node.replaceProps = legacyReplaceProps; |
| |
| if ("development" !== 'production') { |
| if (canDefineProperty) { |
| Object.defineProperties(node, legacyPropsDescriptor); |
| } else { |
| // updateComponent will update this property on subsequent renders |
| node.props = this._currentElement.props; |
| } |
| } else { |
| // updateComponent will update this property on subsequent renders |
| node.props = this._currentElement.props; |
| } |
| |
| this._nodeWithLegacyProperties = node; |
| } |
| return this._nodeWithLegacyProperties; |
| } |
| |
| }; |
| |
| ReactPerf.measureMethods(ReactDOMComponent, 'ReactDOMComponent', { |
| mountComponent: 'mountComponent', |
| updateComponent: 'updateComponent' |
| }); |
| |
| assign(ReactDOMComponent.prototype, ReactDOMComponent.Mixin, ReactMultiChild.Mixin); |
| |
| module.exports = ReactDOMComponent; |
| },{"10":10,"11":11,"117":117,"121":121,"133":133,"138":138,"139":139,"144":144,"15":15,"161":161,"166":166,"171":171,"173":173,"2":2,"24":24,"28":28,"35":35,"41":41,"46":46,"47":47,"48":48,"5":5,"52":52,"72":72,"73":73,"78":78,"95":95}],43:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMFactories |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| var ReactElementValidator = _dereq_(58); |
| |
| var mapObject = _dereq_(167); |
| |
| /** |
| * Create a factory that creates HTML tag elements. |
| * |
| * @param {string} tag Tag name (e.g. `div`). |
| * @private |
| */ |
| function createDOMFactory(tag) { |
| if ("development" !== 'production') { |
| return ReactElementValidator.createFactory(tag); |
| } |
| return ReactElement.createFactory(tag); |
| } |
| |
| /** |
| * Creates a mapping from supported HTML tags to `ReactDOMComponent` classes. |
| * This is also accessible via `React.DOM`. |
| * |
| * @public |
| */ |
| var ReactDOMFactories = mapObject({ |
| a: 'a', |
| abbr: 'abbr', |
| address: 'address', |
| area: 'area', |
| article: 'article', |
| aside: 'aside', |
| audio: 'audio', |
| b: 'b', |
| base: 'base', |
| bdi: 'bdi', |
| bdo: 'bdo', |
| big: 'big', |
| blockquote: 'blockquote', |
| body: 'body', |
| br: 'br', |
| button: 'button', |
| canvas: 'canvas', |
| caption: 'caption', |
| cite: 'cite', |
| code: 'code', |
| col: 'col', |
| colgroup: 'colgroup', |
| data: 'data', |
| datalist: 'datalist', |
| dd: 'dd', |
| del: 'del', |
| details: 'details', |
| dfn: 'dfn', |
| dialog: 'dialog', |
| div: 'div', |
| dl: 'dl', |
| dt: 'dt', |
| em: 'em', |
| embed: 'embed', |
| fieldset: 'fieldset', |
| figcaption: 'figcaption', |
| figure: 'figure', |
| footer: 'footer', |
| form: 'form', |
| h1: 'h1', |
| h2: 'h2', |
| h3: 'h3', |
| h4: 'h4', |
| h5: 'h5', |
| h6: 'h6', |
| head: 'head', |
| header: 'header', |
| hgroup: 'hgroup', |
| hr: 'hr', |
| html: 'html', |
| i: 'i', |
| iframe: 'iframe', |
| img: 'img', |
| input: 'input', |
| ins: 'ins', |
| kbd: 'kbd', |
| keygen: 'keygen', |
| label: 'label', |
| legend: 'legend', |
| li: 'li', |
| link: 'link', |
| main: 'main', |
| map: 'map', |
| mark: 'mark', |
| menu: 'menu', |
| menuitem: 'menuitem', |
| meta: 'meta', |
| meter: 'meter', |
| nav: 'nav', |
| noscript: 'noscript', |
| object: 'object', |
| ol: 'ol', |
| optgroup: 'optgroup', |
| option: 'option', |
| output: 'output', |
| p: 'p', |
| param: 'param', |
| picture: 'picture', |
| pre: 'pre', |
| progress: 'progress', |
| q: 'q', |
| rp: 'rp', |
| rt: 'rt', |
| ruby: 'ruby', |
| s: 's', |
| samp: 'samp', |
| script: 'script', |
| section: 'section', |
| select: 'select', |
| small: 'small', |
| source: 'source', |
| span: 'span', |
| strong: 'strong', |
| style: 'style', |
| sub: 'sub', |
| summary: 'summary', |
| sup: 'sup', |
| table: 'table', |
| tbody: 'tbody', |
| td: 'td', |
| textarea: 'textarea', |
| tfoot: 'tfoot', |
| th: 'th', |
| thead: 'thead', |
| time: 'time', |
| title: 'title', |
| tr: 'tr', |
| track: 'track', |
| u: 'u', |
| ul: 'ul', |
| 'var': 'var', |
| video: 'video', |
| wbr: 'wbr', |
| |
| // SVG |
| circle: 'circle', |
| clipPath: 'clipPath', |
| defs: 'defs', |
| ellipse: 'ellipse', |
| g: 'g', |
| image: 'image', |
| line: 'line', |
| linearGradient: 'linearGradient', |
| mask: 'mask', |
| path: 'path', |
| pattern: 'pattern', |
| polygon: 'polygon', |
| polyline: 'polyline', |
| radialGradient: 'radialGradient', |
| rect: 'rect', |
| stop: 'stop', |
| svg: 'svg', |
| text: 'text', |
| tspan: 'tspan' |
| |
| }, createDOMFactory); |
| |
| module.exports = ReactDOMFactories; |
| },{"167":167,"57":57,"58":58}],44:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMFeatureFlags |
| */ |
| |
| 'use strict'; |
| |
| var ReactDOMFeatureFlags = { |
| useCreateElement: false |
| }; |
| |
| module.exports = ReactDOMFeatureFlags; |
| },{}],45:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMIDOperations |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var DOMChildrenOperations = _dereq_(9); |
| var DOMPropertyOperations = _dereq_(11); |
| var ReactMount = _dereq_(72); |
| var ReactPerf = _dereq_(78); |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Errors for properties that should not be updated with `updatePropertyByID()`. |
| * |
| * @type {object} |
| * @private |
| */ |
| var INVALID_PROPERTY_ERRORS = { |
| dangerouslySetInnerHTML: '`dangerouslySetInnerHTML` must be set using `updateInnerHTMLByID()`.', |
| style: '`style` must be set using `updateStylesByID()`.' |
| }; |
| |
| /** |
| * Operations used to process updates to DOM nodes. |
| */ |
| var ReactDOMIDOperations = { |
| |
| /** |
| * Updates a DOM node with new property values. This should only be used to |
| * update DOM properties in `DOMProperty`. |
| * |
| * @param {string} id ID of the node to update. |
| * @param {string} name A valid property name, see `DOMProperty`. |
| * @param {*} value New value of the property. |
| * @internal |
| */ |
| updatePropertyByID: function (id, name, value) { |
| var node = ReactMount.getNode(id); |
| !!INVALID_PROPERTY_ERRORS.hasOwnProperty(name) ? "development" !== 'production' ? invariant(false, 'updatePropertyByID(...): %s', INVALID_PROPERTY_ERRORS[name]) : invariant(false) : undefined; |
| |
| // If we're updating to null or undefined, we should remove the property |
| // from the DOM node instead of inadvertantly setting to a string. This |
| // brings us in line with the same behavior we have on initial render. |
| if (value != null) { |
| DOMPropertyOperations.setValueForProperty(node, name, value); |
| } else { |
| DOMPropertyOperations.deleteValueForProperty(node, name); |
| } |
| }, |
| |
| /** |
| * Replaces a DOM node that exists in the document with markup. |
| * |
| * @param {string} id ID of child to be replaced. |
| * @param {string} markup Dangerous markup to inject in place of child. |
| * @internal |
| * @see {Danger.dangerouslyReplaceNodeWithMarkup} |
| */ |
| dangerouslyReplaceNodeWithMarkupByID: function (id, markup) { |
| var node = ReactMount.getNode(id); |
| DOMChildrenOperations.dangerouslyReplaceNodeWithMarkup(node, markup); |
| }, |
| |
| /** |
| * Updates a component's children by processing a series of updates. |
| * |
| * @param {array<object>} updates List of update configurations. |
| * @param {array<string>} markup List of markup strings. |
| * @internal |
| */ |
| dangerouslyProcessChildrenUpdates: function (updates, markup) { |
| for (var i = 0; i < updates.length; i++) { |
| updates[i].parentNode = ReactMount.getNode(updates[i].parentID); |
| } |
| DOMChildrenOperations.processUpdates(updates, markup); |
| } |
| }; |
| |
| ReactPerf.measureMethods(ReactDOMIDOperations, 'ReactDOMIDOperations', { |
| dangerouslyReplaceNodeWithMarkupByID: 'dangerouslyReplaceNodeWithMarkupByID', |
| dangerouslyProcessChildrenUpdates: 'dangerouslyProcessChildrenUpdates' |
| }); |
| |
| module.exports = ReactDOMIDOperations; |
| },{"11":11,"161":161,"72":72,"78":78,"9":9}],46:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMInput |
| */ |
| |
| 'use strict'; |
| |
| var ReactDOMIDOperations = _dereq_(45); |
| var LinkedValueUtils = _dereq_(23); |
| var ReactMount = _dereq_(72); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| |
| var instancesByReactID = {}; |
| |
| function forceUpdateIfMounted() { |
| if (this._rootNodeID) { |
| // DOM component is still mounted; update |
| ReactDOMInput.updateWrapper(this); |
| } |
| } |
| |
| /** |
| * Implements an <input> native 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 |
| */ |
| var ReactDOMInput = { |
| getNativeProps: function (inst, props, context) { |
| var value = LinkedValueUtils.getValue(props); |
| var checked = LinkedValueUtils.getChecked(props); |
| |
| var nativeProps = assign({}, props, { |
| defaultChecked: undefined, |
| defaultValue: undefined, |
| value: value != null ? value : inst._wrapperState.initialValue, |
| checked: checked != null ? checked : inst._wrapperState.initialChecked, |
| onChange: inst._wrapperState.onChange |
| }); |
| |
| return nativeProps; |
| }, |
| |
| mountWrapper: function (inst, props) { |
| if ("development" !== 'production') { |
| LinkedValueUtils.checkPropTypes('input', props, inst._currentElement._owner); |
| } |
| |
| var defaultValue = props.defaultValue; |
| inst._wrapperState = { |
| initialChecked: props.defaultChecked || false, |
| initialValue: defaultValue != null ? defaultValue : null, |
| onChange: _handleChange.bind(inst) |
| }; |
| }, |
| |
| mountReadyWrapper: function (inst) { |
| // Can't be in mountWrapper or else server rendering leaks. |
| instancesByReactID[inst._rootNodeID] = inst; |
| }, |
| |
| unmountWrapper: function (inst) { |
| delete instancesByReactID[inst._rootNodeID]; |
| }, |
| |
| updateWrapper: function (inst) { |
| var props = inst._currentElement.props; |
| |
| // TODO: Shouldn't this be getChecked(props)? |
| var checked = props.checked; |
| if (checked != null) { |
| ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'checked', checked || false); |
| } |
| |
| var value = LinkedValueUtils.getValue(props); |
| if (value != null) { |
| // Cast `value` to a string to ensure the value is set correctly. While |
| // browsers typically do this as necessary, jsdom doesn't. |
| ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'value', '' + value); |
| } |
| } |
| }; |
| |
| 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 = ReactMount.getNode(this._rootNodeID); |
| 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 with non-React. |
| var otherID = ReactMount.getID(otherNode); |
| !otherID ? "development" !== 'production' ? invariant(false, 'ReactDOMInput: Mixing React and non-React radio inputs with the ' + 'same `name` is not supported.') : invariant(false) : undefined; |
| var otherInstance = instancesByReactID[otherID]; |
| !otherInstance ? "development" !== 'production' ? invariant(false, 'ReactDOMInput: Unknown radio button ID %s.', otherID) : invariant(false) : undefined; |
| // 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; |
| } |
| |
| module.exports = ReactDOMInput; |
| },{"161":161,"23":23,"24":24,"45":45,"72":72,"96":96}],47:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMOption |
| */ |
| |
| 'use strict'; |
| |
| var ReactChildren = _dereq_(32); |
| var ReactDOMSelect = _dereq_(48); |
| |
| var assign = _dereq_(24); |
| var warning = _dereq_(173); |
| |
| var valueContextKey = ReactDOMSelect.valueContextKey; |
| |
| /** |
| * Implements an <option> native component that warns when `selected` is set. |
| */ |
| var ReactDOMOption = { |
| mountWrapper: function (inst, props, context) { |
| // TODO (yungsters): Remove support for `selected` in <option>. |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(props.selected == null, 'Use the `defaultValue` or `value` props on <select> instead of ' + 'setting `selected` on <option>.') : undefined; |
| } |
| |
| // Look up whether this option is 'selected' via context |
| var selectValue = context[valueContextKey]; |
| |
| // If context key is null (e.g., no specified value or after initial mount) |
| // or missing (e.g., for <datalist>), we don't change props.selected |
| var selected = null; |
| if (selectValue != null) { |
| selected = false; |
| if (Array.isArray(selectValue)) { |
| // multiple |
| for (var i = 0; i < selectValue.length; i++) { |
| if ('' + selectValue[i] === '' + props.value) { |
| selected = true; |
| break; |
| } |
| } |
| } else { |
| selected = '' + selectValue === '' + props.value; |
| } |
| } |
| |
| inst._wrapperState = { selected: selected }; |
| }, |
| |
| getNativeProps: function (inst, props, context) { |
| var nativeProps = assign({ selected: undefined, children: undefined }, props); |
| |
| // Read state only from initial mount because <select> updates value |
| // manually; we need the initial state only for server rendering |
| if (inst._wrapperState.selected != null) { |
| nativeProps.selected = inst._wrapperState.selected; |
| } |
| |
| var content = ''; |
| |
| // Flatten children and warn if they aren't strings or numbers; |
| // invalid types are ignored. |
| ReactChildren.forEach(props.children, function (child) { |
| if (child == null) { |
| return; |
| } |
| if (typeof child === 'string' || typeof child === 'number') { |
| content += child; |
| } else { |
| "development" !== 'production' ? warning(false, 'Only strings and numbers are supported as <option> children.') : undefined; |
| } |
| }); |
| |
| nativeProps.children = content; |
| return nativeProps; |
| } |
| |
| }; |
| |
| module.exports = ReactDOMOption; |
| },{"173":173,"24":24,"32":32,"48":48}],48:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMSelect |
| */ |
| |
| 'use strict'; |
| |
| var LinkedValueUtils = _dereq_(23); |
| var ReactMount = _dereq_(72); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var warning = _dereq_(173); |
| |
| var valueContextKey = '__ReactDOMSelect_value$' + Math.random().toString(36).slice(2); |
| |
| function updateOptionsIfPendingUpdateAndMounted() { |
| if (this._rootNodeID && this._wrapperState.pendingUpdate) { |
| this._wrapperState.pendingUpdate = false; |
| |
| var props = this._currentElement.props; |
| var value = LinkedValueUtils.getValue(props); |
| |
| if (value != null) { |
| updateOptions(this, props, value); |
| } |
| } |
| } |
| |
| function getDeclarationErrorAddendum(owner) { |
| if (owner) { |
| var name = owner.getName(); |
| if (name) { |
| return ' Check the render method of `' + name + '`.'; |
| } |
| } |
| return ''; |
| } |
| |
| var valuePropNames = ['value', 'defaultValue']; |
| |
| /** |
| * Validation function for `value` and `defaultValue`. |
| * @private |
| */ |
| function checkSelectPropTypes(inst, props) { |
| var owner = inst._currentElement._owner; |
| LinkedValueUtils.checkPropTypes('select', props, owner); |
| |
| for (var i = 0; i < valuePropNames.length; i++) { |
| var propName = valuePropNames[i]; |
| if (props[propName] == null) { |
| continue; |
| } |
| if (props.multiple) { |
| "development" !== 'production' ? warning(Array.isArray(props[propName]), 'The `%s` prop supplied to <select> must be an array if ' + '`multiple` is true.%s', propName, getDeclarationErrorAddendum(owner)) : undefined; |
| } else { |
| "development" !== 'production' ? warning(!Array.isArray(props[propName]), 'The `%s` prop supplied to <select> must be a scalar ' + 'value if `multiple` is false.%s', propName, getDeclarationErrorAddendum(owner)) : undefined; |
| } |
| } |
| } |
| |
| /** |
| * @param {ReactDOMComponent} inst |
| * @param {boolean} multiple |
| * @param {*} propValue A stringable (with `multiple`, a list of stringables). |
| * @private |
| */ |
| function updateOptions(inst, multiple, propValue) { |
| var selectedValue, i; |
| var options = ReactMount.getNode(inst._rootNodeID).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; |
| } |
| } |
| } |
| |
| /** |
| * Implements a <select> native 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. |
| */ |
| var ReactDOMSelect = { |
| valueContextKey: valueContextKey, |
| |
| getNativeProps: function (inst, props, context) { |
| return assign({}, props, { |
| onChange: inst._wrapperState.onChange, |
| value: undefined |
| }); |
| }, |
| |
| mountWrapper: function (inst, props) { |
| if ("development" !== 'production') { |
| checkSelectPropTypes(inst, props); |
| } |
| |
| var value = LinkedValueUtils.getValue(props); |
| inst._wrapperState = { |
| pendingUpdate: false, |
| initialValue: value != null ? value : props.defaultValue, |
| onChange: _handleChange.bind(inst), |
| wasMultiple: Boolean(props.multiple) |
| }; |
| }, |
| |
| processChildContext: function (inst, props, context) { |
| // Pass down initial value so initial generated markup has correct |
| // `selected` attributes |
| var childContext = assign({}, context); |
| childContext[valueContextKey] = inst._wrapperState.initialValue; |
| return childContext; |
| }, |
| |
| postUpdateWrapper: function (inst) { |
| var props = inst._currentElement.props; |
| |
| // After the initial mount, we control selected-ness manually so don't pass |
| // the context value down |
| inst._wrapperState.initialValue = undefined; |
| |
| var wasMultiple = inst._wrapperState.wasMultiple; |
| inst._wrapperState.wasMultiple = Boolean(props.multiple); |
| |
| var value = LinkedValueUtils.getValue(props); |
| if (value != null) { |
| inst._wrapperState.pendingUpdate = false; |
| updateOptions(inst, Boolean(props.multiple), value); |
| } else if (wasMultiple !== Boolean(props.multiple)) { |
| // For simplicity, reapply `defaultValue` if `multiple` is toggled. |
| if (props.defaultValue != null) { |
| updateOptions(inst, Boolean(props.multiple), props.defaultValue); |
| } else { |
| // Revert the select back to its default unselected state. |
| updateOptions(inst, Boolean(props.multiple), props.multiple ? [] : ''); |
| } |
| } |
| } |
| }; |
| |
| function _handleChange(event) { |
| var props = this._currentElement.props; |
| var returnValue = LinkedValueUtils.executeOnChange(props, event); |
| |
| this._wrapperState.pendingUpdate = true; |
| ReactUpdates.asap(updateOptionsIfPendingUpdateAndMounted, this); |
| return returnValue; |
| } |
| |
| module.exports = ReactDOMSelect; |
| },{"173":173,"23":23,"24":24,"72":72,"96":96}],49:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMSelection |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var getNodeForCharacterOffset = _dereq_(130); |
| var getTextContentAccessor = _dereq_(131); |
| |
| /** |
| * 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. |
| */ |
| function isCollapsed(anchorNode, anchorOffset, focusNode, focusOffset) { |
| return anchorNode === focusNode && anchorOffset === focusOffset; |
| } |
| |
| /** |
| * 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} |
| */ |
| 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 |
| }; |
| } |
| |
| /** |
| * @param {DOMElement} node |
| * @return {?object} |
| */ |
| function getModernOffsets(node) { |
| var selection = window.getSelection && window.getSelection(); |
| |
| if (!selection || selection.rangeCount === 0) { |
| return null; |
| } |
| |
| var anchorNode = selection.anchorNode; |
| var anchorOffset = selection.anchorOffset; |
| var focusNode = selection.focusNode; |
| var focusOffset = selection.focusOffset; |
| |
| var currentRange = selection.getRangeAt(0); |
| |
| // In Firefox, range.startContainer and range.endContainer can be "anonymous |
| // divs", e.g. the up/down buttons on an <input type="number">. Anonymous |
| // divs do not seem to expose properties, triggering a "Permission denied |
| // error" if any of its properties are accessed. The only seemingly possible |
| // way to avoid erroring is to access a property that typically works for |
| // non-anonymous divs and catch any error that may otherwise arise. See |
| // https://bugzilla.mozilla.org/show_bug.cgi?id=208427 |
| try { |
| /* eslint-disable no-unused-expressions */ |
| currentRange.startContainer.nodeType; |
| currentRange.endContainer.nodeType; |
| /* eslint-enable no-unused-expressions */ |
| } catch (e) { |
| return null; |
| } |
| |
| // If the node and offset values are the same, the selection is collapsed. |
| // `Selection.isCollapsed` is available natively, but IE sometimes gets |
| // this value wrong. |
| var isSelectionCollapsed = isCollapsed(selection.anchorNode, selection.anchorOffset, selection.focusNode, selection.focusOffset); |
| |
| var rangeLength = isSelectionCollapsed ? 0 : currentRange.toString().length; |
| |
| var tempRange = currentRange.cloneRange(); |
| tempRange.selectNodeContents(node); |
| tempRange.setEnd(currentRange.startContainer, currentRange.startOffset); |
| |
| var isTempRangeCollapsed = isCollapsed(tempRange.startContainer, tempRange.startOffset, tempRange.endContainer, tempRange.endOffset); |
| |
| var start = isTempRangeCollapsed ? 0 : tempRange.toString().length; |
| var end = start + rangeLength; |
| |
| // Detect whether the selection is backward. |
| var detectionRange = document.createRange(); |
| detectionRange.setStart(anchorNode, anchorOffset); |
| detectionRange.setEnd(focusNode, focusOffset); |
| var isBackward = detectionRange.collapsed; |
| |
| return { |
| start: isBackward ? end : start, |
| end: isBackward ? start : end |
| }; |
| } |
| |
| /** |
| * @param {DOMElement|DOMTextNode} node |
| * @param {object} offsets |
| */ |
| function setIEOffsets(node, offsets) { |
| var range = document.selection.createRange().duplicate(); |
| var start, end; |
| |
| if (typeof 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(); |
| } |
| |
| /** |
| * 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 programatically 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 |
| */ |
| 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 = typeof 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); |
| } |
| } |
| } |
| |
| var useIEOffsets = ExecutionEnvironment.canUseDOM && 'selection' in document && !('getSelection' in window); |
| |
| var ReactDOMSelection = { |
| /** |
| * @param {DOMElement} node |
| */ |
| getOffsets: useIEOffsets ? getIEOffsets : getModernOffsets, |
| |
| /** |
| * @param {DOMElement|DOMTextNode} node |
| * @param {object} offsets |
| */ |
| setOffsets: useIEOffsets ? setIEOffsets : setModernOffsets |
| }; |
| |
| module.exports = ReactDOMSelection; |
| },{"130":130,"131":131,"147":147}],50:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMServer |
| */ |
| |
| 'use strict'; |
| |
| var ReactDefaultInjection = _dereq_(54); |
| var ReactServerRendering = _dereq_(88); |
| var ReactVersion = _dereq_(97); |
| |
| ReactDefaultInjection.inject(); |
| |
| var ReactDOMServer = { |
| renderToString: ReactServerRendering.renderToString, |
| renderToStaticMarkup: ReactServerRendering.renderToStaticMarkup, |
| version: ReactVersion |
| }; |
| |
| module.exports = ReactDOMServer; |
| },{"54":54,"88":88,"97":97}],51:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMTextComponent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var DOMChildrenOperations = _dereq_(9); |
| var DOMPropertyOperations = _dereq_(11); |
| var ReactComponentBrowserEnvironment = _dereq_(35); |
| var ReactMount = _dereq_(72); |
| |
| var assign = _dereq_(24); |
| var escapeTextContentForBrowser = _dereq_(121); |
| var setTextContent = _dereq_(139); |
| var validateDOMNesting = _dereq_(144); |
| |
| /** |
| * 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 in elements 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 |
| */ |
| var ReactDOMTextComponent = function (props) { |
| // This constructor and its argument is currently used by mocks. |
| }; |
| |
| assign(ReactDOMTextComponent.prototype, { |
| |
| /** |
| * @param {ReactText} text |
| * @internal |
| */ |
| construct: function (text) { |
| // TODO: This is really a ReactText (ReactNode), not a ReactElement |
| this._currentElement = text; |
| this._stringText = '' + text; |
| |
| // Properties |
| this._rootNodeID = null; |
| this._mountIndex = 0; |
| }, |
| |
| /** |
| * Creates the markup for this text node. This node is not intended to have |
| * any features besides containing text content. |
| * |
| * @param {string} rootID DOM ID of the root node. |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @return {string} Markup for this text node. |
| * @internal |
| */ |
| mountComponent: function (rootID, transaction, context) { |
| if ("development" !== 'production') { |
| if (context[validateDOMNesting.ancestorInfoContextKey]) { |
| validateDOMNesting('span', null, context[validateDOMNesting.ancestorInfoContextKey]); |
| } |
| } |
| |
| this._rootNodeID = rootID; |
| if (transaction.useCreateElement) { |
| var ownerDocument = context[ReactMount.ownerDocumentContextKey]; |
| var el = ownerDocument.createElement('span'); |
| DOMPropertyOperations.setAttributeForID(el, rootID); |
| // Populate node cache |
| ReactMount.getID(el); |
| setTextContent(el, this._stringText); |
| return el; |
| } else { |
| var escapedText = escapeTextContentForBrowser(this._stringText); |
| |
| if (transaction.renderToStaticMarkup) { |
| // Normally we'd wrap this in a `span` for the reasons stated above, but |
| // since this is a situation where React won't take over (static pages), |
| // we can simply return the text as it is. |
| return escapedText; |
| } |
| |
| return '<span ' + DOMPropertyOperations.createMarkupForID(rootID) + '>' + escapedText + '</span>'; |
| } |
| }, |
| |
| /** |
| * Updates this component by updating the text content. |
| * |
| * @param {ReactText} nextText The next text content |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| */ |
| receiveComponent: function (nextText, transaction) { |
| if (nextText !== this._currentElement) { |
| this._currentElement = nextText; |
| var nextStringText = '' + nextText; |
| if (nextStringText !== this._stringText) { |
| // TODO: Save this as pending props and use performUpdateIfNecessary |
| // and/or updateComponent to do the actual update for consistency with |
| // other component types? |
| this._stringText = nextStringText; |
| var node = ReactMount.getNode(this._rootNodeID); |
| DOMChildrenOperations.updateTextContent(node, nextStringText); |
| } |
| } |
| }, |
| |
| unmountComponent: function () { |
| ReactComponentBrowserEnvironment.unmountIDFromEnvironment(this._rootNodeID); |
| } |
| |
| }); |
| |
| module.exports = ReactDOMTextComponent; |
| },{"11":11,"121":121,"139":139,"144":144,"24":24,"35":35,"72":72,"9":9}],52:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDOMTextarea |
| */ |
| |
| 'use strict'; |
| |
| var LinkedValueUtils = _dereq_(23); |
| var ReactDOMIDOperations = _dereq_(45); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| function forceUpdateIfMounted() { |
| if (this._rootNodeID) { |
| // DOM component is still mounted; update |
| ReactDOMTextarea.updateWrapper(this); |
| } |
| } |
| |
| /** |
| * Implements a <textarea> native 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). |
| */ |
| var ReactDOMTextarea = { |
| getNativeProps: function (inst, props, context) { |
| !(props.dangerouslySetInnerHTML == null) ? "development" !== 'production' ? invariant(false, '`dangerouslySetInnerHTML` does not make sense on <textarea>.') : invariant(false) : undefined; |
| |
| // Always set children to the same thing. In IE9, the selection range will |
| // get reset if `textContent` is mutated. |
| var nativeProps = assign({}, props, { |
| defaultValue: undefined, |
| value: undefined, |
| children: inst._wrapperState.initialValue, |
| onChange: inst._wrapperState.onChange |
| }); |
| |
| return nativeProps; |
| }, |
| |
| mountWrapper: function (inst, props) { |
| if ("development" !== 'production') { |
| LinkedValueUtils.checkPropTypes('textarea', props, inst._currentElement._owner); |
| } |
| |
| var defaultValue = props.defaultValue; |
| // TODO (yungsters): Remove support for children content in <textarea>. |
| var children = props.children; |
| if (children != null) { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, 'Use the `defaultValue` or `value` props instead of setting ' + 'children on <textarea>.') : undefined; |
| } |
| !(defaultValue == null) ? "development" !== 'production' ? invariant(false, 'If you supply `defaultValue` on a <textarea>, do not pass children.') : invariant(false) : undefined; |
| if (Array.isArray(children)) { |
| !(children.length <= 1) ? "development" !== 'production' ? invariant(false, '<textarea> can only have at most one child.') : invariant(false) : undefined; |
| children = children[0]; |
| } |
| |
| defaultValue = '' + children; |
| } |
| if (defaultValue == null) { |
| defaultValue = ''; |
| } |
| var value = LinkedValueUtils.getValue(props); |
| |
| inst._wrapperState = { |
| // We save the initial value so that `ReactDOMComponent` doesn't update |
| // `textContent` (unnecessary since we update value). |
| // The initial value can be a boolean or object so that's why it's |
| // forced to be a string. |
| initialValue: '' + (value != null ? value : defaultValue), |
| onChange: _handleChange.bind(inst) |
| }; |
| }, |
| |
| updateWrapper: function (inst) { |
| var props = inst._currentElement.props; |
| var value = LinkedValueUtils.getValue(props); |
| if (value != null) { |
| // Cast `value` to a string to ensure the value is set correctly. While |
| // browsers typically do this as necessary, jsdom doesn't. |
| ReactDOMIDOperations.updatePropertyByID(inst._rootNodeID, 'value', '' + value); |
| } |
| } |
| }; |
| |
| function _handleChange(event) { |
| var props = this._currentElement.props; |
| var returnValue = LinkedValueUtils.executeOnChange(props, event); |
| ReactUpdates.asap(forceUpdateIfMounted, this); |
| return returnValue; |
| } |
| |
| module.exports = ReactDOMTextarea; |
| },{"161":161,"173":173,"23":23,"24":24,"45":45,"96":96}],53:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDefaultBatchingStrategy |
| */ |
| |
| 'use strict'; |
| |
| var ReactUpdates = _dereq_(96); |
| var Transaction = _dereq_(113); |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| |
| var RESET_BATCHED_UPDATES = { |
| initialize: emptyFunction, |
| close: function () { |
| ReactDefaultBatchingStrategy.isBatchingUpdates = false; |
| } |
| }; |
| |
| var FLUSH_BATCHED_UPDATES = { |
| initialize: emptyFunction, |
| close: ReactUpdates.flushBatchedUpdates.bind(ReactUpdates) |
| }; |
| |
| var TRANSACTION_WRAPPERS = [FLUSH_BATCHED_UPDATES, RESET_BATCHED_UPDATES]; |
| |
| function ReactDefaultBatchingStrategyTransaction() { |
| this.reinitializeTransaction(); |
| } |
| |
| assign(ReactDefaultBatchingStrategyTransaction.prototype, Transaction.Mixin, { |
| getTransactionWrappers: function () { |
| return TRANSACTION_WRAPPERS; |
| } |
| }); |
| |
| var transaction = new ReactDefaultBatchingStrategyTransaction(); |
| |
| var ReactDefaultBatchingStrategy = { |
| isBatchingUpdates: false, |
| |
| /** |
| * Call the provided function in a context within which calls to `setState` |
| * and friends are batched such that components aren't updated unnecessarily. |
| */ |
| batchedUpdates: function (callback, a, b, c, d, e) { |
| var alreadyBatchingUpdates = ReactDefaultBatchingStrategy.isBatchingUpdates; |
| |
| ReactDefaultBatchingStrategy.isBatchingUpdates = true; |
| |
| // The code is written this way to avoid extra allocations |
| if (alreadyBatchingUpdates) { |
| callback(a, b, c, d, e); |
| } else { |
| transaction.perform(callback, null, a, b, c, d, e); |
| } |
| } |
| }; |
| |
| module.exports = ReactDefaultBatchingStrategy; |
| },{"113":113,"153":153,"24":24,"96":96}],54:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDefaultInjection |
| */ |
| |
| 'use strict'; |
| |
| var BeforeInputEventPlugin = _dereq_(3); |
| var ChangeEventPlugin = _dereq_(7); |
| var ClientReactRootIndex = _dereq_(8); |
| var DefaultEventPluginOrder = _dereq_(13); |
| var EnterLeaveEventPlugin = _dereq_(14); |
| var ExecutionEnvironment = _dereq_(147); |
| var HTMLDOMPropertyConfig = _dereq_(21); |
| var ReactBrowserComponentMixin = _dereq_(27); |
| var ReactComponentBrowserEnvironment = _dereq_(35); |
| var ReactDefaultBatchingStrategy = _dereq_(53); |
| var ReactDOMComponent = _dereq_(42); |
| var ReactDOMTextComponent = _dereq_(51); |
| var ReactEventListener = _dereq_(63); |
| var ReactInjection = _dereq_(65); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactMount = _dereq_(72); |
| var ReactReconcileTransaction = _dereq_(83); |
| var SelectEventPlugin = _dereq_(99); |
| var ServerReactRootIndex = _dereq_(100); |
| var SimpleEventPlugin = _dereq_(101); |
| var SVGDOMPropertyConfig = _dereq_(98); |
| |
| var alreadyInjected = false; |
| |
| function inject() { |
| if (alreadyInjected) { |
| // TODO: This is currently true because these injections are shared between |
| // the client and the server package. They should be built independently |
| // and not share any injection state. Then this problem will be solved. |
| return; |
| } |
| alreadyInjected = true; |
| |
| ReactInjection.EventEmitter.injectReactEventListener(ReactEventListener); |
| |
| /** |
| * Inject modules for resolving DOM hierarchy and plugin ordering. |
| */ |
| ReactInjection.EventPluginHub.injectEventPluginOrder(DefaultEventPluginOrder); |
| ReactInjection.EventPluginHub.injectInstanceHandle(ReactInstanceHandles); |
| ReactInjection.EventPluginHub.injectMount(ReactMount); |
| |
| /** |
| * Some important event plugins included by default (without having to require |
| * them). |
| */ |
| ReactInjection.EventPluginHub.injectEventPluginsByName({ |
| SimpleEventPlugin: SimpleEventPlugin, |
| EnterLeaveEventPlugin: EnterLeaveEventPlugin, |
| ChangeEventPlugin: ChangeEventPlugin, |
| SelectEventPlugin: SelectEventPlugin, |
| BeforeInputEventPlugin: BeforeInputEventPlugin |
| }); |
| |
| ReactInjection.NativeComponent.injectGenericComponentClass(ReactDOMComponent); |
| |
| ReactInjection.NativeComponent.injectTextComponentClass(ReactDOMTextComponent); |
| |
| ReactInjection.Class.injectMixin(ReactBrowserComponentMixin); |
| |
| ReactInjection.DOMProperty.injectDOMPropertyConfig(HTMLDOMPropertyConfig); |
| ReactInjection.DOMProperty.injectDOMPropertyConfig(SVGDOMPropertyConfig); |
| |
| ReactInjection.EmptyComponent.injectEmptyComponent('noscript'); |
| |
| ReactInjection.Updates.injectReconcileTransaction(ReactReconcileTransaction); |
| ReactInjection.Updates.injectBatchingStrategy(ReactDefaultBatchingStrategy); |
| |
| ReactInjection.RootIndex.injectCreateReactRootIndex(ExecutionEnvironment.canUseDOM ? ClientReactRootIndex.createReactRootIndex : ServerReactRootIndex.createReactRootIndex); |
| |
| ReactInjection.Component.injectEnvironment(ReactComponentBrowserEnvironment); |
| |
| if ("development" !== 'production') { |
| var url = ExecutionEnvironment.canUseDOM && window.location.href || ''; |
| if (/[?&]react_perf\b/.test(url)) { |
| var ReactDefaultPerf = _dereq_(55); |
| ReactDefaultPerf.start(); |
| } |
| } |
| } |
| |
| module.exports = { |
| inject: inject |
| }; |
| },{"100":100,"101":101,"13":13,"14":14,"147":147,"21":21,"27":27,"3":3,"35":35,"42":42,"51":51,"53":53,"55":55,"63":63,"65":65,"67":67,"7":7,"72":72,"8":8,"83":83,"98":98,"99":99}],55:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDefaultPerf |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| var ReactDefaultPerfAnalysis = _dereq_(56); |
| var ReactMount = _dereq_(72); |
| var ReactPerf = _dereq_(78); |
| |
| var performanceNow = _dereq_(170); |
| |
| function roundFloat(val) { |
| return Math.floor(val * 100) / 100; |
| } |
| |
| function addValue(obj, key, val) { |
| obj[key] = (obj[key] || 0) + val; |
| } |
| |
| var ReactDefaultPerf = { |
| _allMeasurements: [], // last item in the list is the current one |
| _mountStack: [0], |
| _injected: false, |
| |
| start: function () { |
| if (!ReactDefaultPerf._injected) { |
| ReactPerf.injection.injectMeasure(ReactDefaultPerf.measure); |
| } |
| |
| ReactDefaultPerf._allMeasurements.length = 0; |
| ReactPerf.enableMeasure = true; |
| }, |
| |
| stop: function () { |
| ReactPerf.enableMeasure = false; |
| }, |
| |
| getLastMeasurements: function () { |
| return ReactDefaultPerf._allMeasurements; |
| }, |
| |
| printExclusive: function (measurements) { |
| measurements = measurements || ReactDefaultPerf._allMeasurements; |
| var summary = ReactDefaultPerfAnalysis.getExclusiveSummary(measurements); |
| console.table(summary.map(function (item) { |
| return { |
| 'Component class name': item.componentName, |
| 'Total inclusive time (ms)': roundFloat(item.inclusive), |
| 'Exclusive mount time (ms)': roundFloat(item.exclusive), |
| 'Exclusive render time (ms)': roundFloat(item.render), |
| 'Mount time per instance (ms)': roundFloat(item.exclusive / item.count), |
| 'Render time per instance (ms)': roundFloat(item.render / item.count), |
| 'Instances': item.count |
| }; |
| })); |
| // TODO: ReactDefaultPerfAnalysis.getTotalTime() does not return the correct |
| // number. |
| }, |
| |
| printInclusive: function (measurements) { |
| measurements = measurements || ReactDefaultPerf._allMeasurements; |
| var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements); |
| console.table(summary.map(function (item) { |
| return { |
| 'Owner > component': item.componentName, |
| 'Inclusive time (ms)': roundFloat(item.time), |
| 'Instances': item.count |
| }; |
| })); |
| console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'); |
| }, |
| |
| getMeasurementsSummaryMap: function (measurements) { |
| var summary = ReactDefaultPerfAnalysis.getInclusiveSummary(measurements, true); |
| return summary.map(function (item) { |
| return { |
| 'Owner > component': item.componentName, |
| 'Wasted time (ms)': item.time, |
| 'Instances': item.count |
| }; |
| }); |
| }, |
| |
| printWasted: function (measurements) { |
| measurements = measurements || ReactDefaultPerf._allMeasurements; |
| console.table(ReactDefaultPerf.getMeasurementsSummaryMap(measurements)); |
| console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'); |
| }, |
| |
| printDOM: function (measurements) { |
| measurements = measurements || ReactDefaultPerf._allMeasurements; |
| var summary = ReactDefaultPerfAnalysis.getDOMSummary(measurements); |
| console.table(summary.map(function (item) { |
| var result = {}; |
| result[DOMProperty.ID_ATTRIBUTE_NAME] = item.id; |
| result.type = item.type; |
| result.args = JSON.stringify(item.args); |
| return result; |
| })); |
| console.log('Total time:', ReactDefaultPerfAnalysis.getTotalTime(measurements).toFixed(2) + ' ms'); |
| }, |
| |
| _recordWrite: function (id, fnName, totalTime, args) { |
| // TODO: totalTime isn't that useful since it doesn't count paints/reflows |
| var writes = ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1].writes; |
| writes[id] = writes[id] || []; |
| writes[id].push({ |
| type: fnName, |
| time: totalTime, |
| args: args |
| }); |
| }, |
| |
| measure: function (moduleName, fnName, func) { |
| return function () { |
| for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) { |
| args[_key] = arguments[_key]; |
| } |
| |
| var totalTime; |
| var rv; |
| var start; |
| |
| if (fnName === '_renderNewRootComponent' || fnName === 'flushBatchedUpdates') { |
| // A "measurement" is a set of metrics recorded for each flush. We want |
| // to group the metrics for a given flush together so we can look at the |
| // components that rendered and the DOM operations that actually |
| // happened to determine the amount of "wasted work" performed. |
| ReactDefaultPerf._allMeasurements.push({ |
| exclusive: {}, |
| inclusive: {}, |
| render: {}, |
| counts: {}, |
| writes: {}, |
| displayNames: {}, |
| totalTime: 0, |
| created: {} |
| }); |
| start = performanceNow(); |
| rv = func.apply(this, args); |
| ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1].totalTime = performanceNow() - start; |
| return rv; |
| } else if (fnName === '_mountImageIntoNode' || moduleName === 'ReactBrowserEventEmitter' || moduleName === 'ReactDOMIDOperations' || moduleName === 'CSSPropertyOperations' || moduleName === 'DOMChildrenOperations' || moduleName === 'DOMPropertyOperations') { |
| start = performanceNow(); |
| rv = func.apply(this, args); |
| totalTime = performanceNow() - start; |
| |
| if (fnName === '_mountImageIntoNode') { |
| var mountID = ReactMount.getID(args[1]); |
| ReactDefaultPerf._recordWrite(mountID, fnName, totalTime, args[0]); |
| } else if (fnName === 'dangerouslyProcessChildrenUpdates') { |
| // special format |
| args[0].forEach(function (update) { |
| var writeArgs = {}; |
| if (update.fromIndex !== null) { |
| writeArgs.fromIndex = update.fromIndex; |
| } |
| if (update.toIndex !== null) { |
| writeArgs.toIndex = update.toIndex; |
| } |
| if (update.textContent !== null) { |
| writeArgs.textContent = update.textContent; |
| } |
| if (update.markupIndex !== null) { |
| writeArgs.markup = args[1][update.markupIndex]; |
| } |
| ReactDefaultPerf._recordWrite(update.parentID, update.type, totalTime, writeArgs); |
| }); |
| } else { |
| // basic format |
| var id = args[0]; |
| if (typeof id === 'object') { |
| id = ReactMount.getID(args[0]); |
| } |
| ReactDefaultPerf._recordWrite(id, fnName, totalTime, Array.prototype.slice.call(args, 1)); |
| } |
| return rv; |
| } else if (moduleName === 'ReactCompositeComponent' && (fnName === 'mountComponent' || fnName === 'updateComponent' || // TODO: receiveComponent()? |
| fnName === '_renderValidatedComponent')) { |
| |
| if (this._currentElement.type === ReactMount.TopLevelWrapper) { |
| return func.apply(this, args); |
| } |
| |
| var rootNodeID = fnName === 'mountComponent' ? args[0] : this._rootNodeID; |
| var isRender = fnName === '_renderValidatedComponent'; |
| var isMount = fnName === 'mountComponent'; |
| |
| var mountStack = ReactDefaultPerf._mountStack; |
| var entry = ReactDefaultPerf._allMeasurements[ReactDefaultPerf._allMeasurements.length - 1]; |
| |
| if (isRender) { |
| addValue(entry.counts, rootNodeID, 1); |
| } else if (isMount) { |
| entry.created[rootNodeID] = true; |
| mountStack.push(0); |
| } |
| |
| start = performanceNow(); |
| rv = func.apply(this, args); |
| totalTime = performanceNow() - start; |
| |
| if (isRender) { |
| addValue(entry.render, rootNodeID, totalTime); |
| } else if (isMount) { |
| var subMountTime = mountStack.pop(); |
| mountStack[mountStack.length - 1] += totalTime; |
| addValue(entry.exclusive, rootNodeID, totalTime - subMountTime); |
| addValue(entry.inclusive, rootNodeID, totalTime); |
| } else { |
| addValue(entry.inclusive, rootNodeID, totalTime); |
| } |
| |
| entry.displayNames[rootNodeID] = { |
| current: this.getName(), |
| owner: this._currentElement._owner ? this._currentElement._owner.getName() : '<root>' |
| }; |
| |
| return rv; |
| } else { |
| return func.apply(this, args); |
| } |
| }; |
| } |
| }; |
| |
| module.exports = ReactDefaultPerf; |
| },{"10":10,"170":170,"56":56,"72":72,"78":78}],56:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactDefaultPerfAnalysis |
| */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| |
| // Don't try to save users less than 1.2ms (a number I made up) |
| var DONT_CARE_THRESHOLD = 1.2; |
| var DOM_OPERATION_TYPES = { |
| '_mountImageIntoNode': 'set innerHTML', |
| INSERT_MARKUP: 'set innerHTML', |
| MOVE_EXISTING: 'move', |
| REMOVE_NODE: 'remove', |
| SET_MARKUP: 'set innerHTML', |
| TEXT_CONTENT: 'set textContent', |
| 'setValueForProperty': 'update attribute', |
| 'setValueForAttribute': 'update attribute', |
| 'deleteValueForProperty': 'remove attribute', |
| 'dangerouslyReplaceNodeWithMarkupByID': 'replace' |
| }; |
| |
| function getTotalTime(measurements) { |
| // TODO: return number of DOM ops? could be misleading. |
| // TODO: measure dropped frames after reconcile? |
| // TODO: log total time of each reconcile and the top-level component |
| // class that triggered it. |
| var totalTime = 0; |
| for (var i = 0; i < measurements.length; i++) { |
| var measurement = measurements[i]; |
| totalTime += measurement.totalTime; |
| } |
| return totalTime; |
| } |
| |
| function getDOMSummary(measurements) { |
| var items = []; |
| measurements.forEach(function (measurement) { |
| Object.keys(measurement.writes).forEach(function (id) { |
| measurement.writes[id].forEach(function (write) { |
| items.push({ |
| id: id, |
| type: DOM_OPERATION_TYPES[write.type] || write.type, |
| args: write.args |
| }); |
| }); |
| }); |
| }); |
| return items; |
| } |
| |
| function getExclusiveSummary(measurements) { |
| var candidates = {}; |
| var displayName; |
| |
| for (var i = 0; i < measurements.length; i++) { |
| var measurement = measurements[i]; |
| var allIDs = assign({}, measurement.exclusive, measurement.inclusive); |
| |
| for (var id in allIDs) { |
| displayName = measurement.displayNames[id].current; |
| |
| candidates[displayName] = candidates[displayName] || { |
| componentName: displayName, |
| inclusive: 0, |
| exclusive: 0, |
| render: 0, |
| count: 0 |
| }; |
| if (measurement.render[id]) { |
| candidates[displayName].render += measurement.render[id]; |
| } |
| if (measurement.exclusive[id]) { |
| candidates[displayName].exclusive += measurement.exclusive[id]; |
| } |
| if (measurement.inclusive[id]) { |
| candidates[displayName].inclusive += measurement.inclusive[id]; |
| } |
| if (measurement.counts[id]) { |
| candidates[displayName].count += measurement.counts[id]; |
| } |
| } |
| } |
| |
| // Now make a sorted array with the results. |
| var arr = []; |
| for (displayName in candidates) { |
| if (candidates[displayName].exclusive >= DONT_CARE_THRESHOLD) { |
| arr.push(candidates[displayName]); |
| } |
| } |
| |
| arr.sort(function (a, b) { |
| return b.exclusive - a.exclusive; |
| }); |
| |
| return arr; |
| } |
| |
| function getInclusiveSummary(measurements, onlyClean) { |
| var candidates = {}; |
| var inclusiveKey; |
| |
| for (var i = 0; i < measurements.length; i++) { |
| var measurement = measurements[i]; |
| var allIDs = assign({}, measurement.exclusive, measurement.inclusive); |
| var cleanComponents; |
| |
| if (onlyClean) { |
| cleanComponents = getUnchangedComponents(measurement); |
| } |
| |
| for (var id in allIDs) { |
| if (onlyClean && !cleanComponents[id]) { |
| continue; |
| } |
| |
| var displayName = measurement.displayNames[id]; |
| |
| // Inclusive time is not useful for many components without knowing where |
| // they are instantiated. So we aggregate inclusive time with both the |
| // owner and current displayName as the key. |
| inclusiveKey = displayName.owner + ' > ' + displayName.current; |
| |
| candidates[inclusiveKey] = candidates[inclusiveKey] || { |
| componentName: inclusiveKey, |
| time: 0, |
| count: 0 |
| }; |
| |
| if (measurement.inclusive[id]) { |
| candidates[inclusiveKey].time += measurement.inclusive[id]; |
| } |
| if (measurement.counts[id]) { |
| candidates[inclusiveKey].count += measurement.counts[id]; |
| } |
| } |
| } |
| |
| // Now make a sorted array with the results. |
| var arr = []; |
| for (inclusiveKey in candidates) { |
| if (candidates[inclusiveKey].time >= DONT_CARE_THRESHOLD) { |
| arr.push(candidates[inclusiveKey]); |
| } |
| } |
| |
| arr.sort(function (a, b) { |
| return b.time - a.time; |
| }); |
| |
| return arr; |
| } |
| |
| function getUnchangedComponents(measurement) { |
| // For a given reconcile, look at which components did not actually |
| // render anything to the DOM and return a mapping of their ID to |
| // the amount of time it took to render the entire subtree. |
| var cleanComponents = {}; |
| var dirtyLeafIDs = Object.keys(measurement.writes); |
| var allIDs = assign({}, measurement.exclusive, measurement.inclusive); |
| |
| for (var id in allIDs) { |
| var isDirty = false; |
| // For each component that rendered, see if a component that triggered |
| // a DOM op is in its subtree. |
| for (var i = 0; i < dirtyLeafIDs.length; i++) { |
| if (dirtyLeafIDs[i].indexOf(id) === 0) { |
| isDirty = true; |
| break; |
| } |
| } |
| // check if component newly created |
| if (measurement.created[id]) { |
| isDirty = true; |
| } |
| if (!isDirty && measurement.counts[id] > 0) { |
| cleanComponents[id] = true; |
| } |
| } |
| return cleanComponents; |
| } |
| |
| var ReactDefaultPerfAnalysis = { |
| getExclusiveSummary: getExclusiveSummary, |
| getInclusiveSummary: getInclusiveSummary, |
| getDOMSummary: getDOMSummary, |
| getTotalTime: getTotalTime |
| }; |
| |
| module.exports = ReactDefaultPerfAnalysis; |
| },{"24":24}],57:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactElement |
| */ |
| |
| 'use strict'; |
| |
| var ReactCurrentOwner = _dereq_(39); |
| |
| var assign = _dereq_(24); |
| var canDefineProperty = _dereq_(117); |
| |
| // The Symbol used to tag the ReactElement type. If there is no native Symbol |
| // nor polyfill, then a plain number is used for performance. |
| var REACT_ELEMENT_TYPE = typeof Symbol === 'function' && Symbol['for'] && Symbol['for']('react.element') || 0xeac7; |
| |
| var RESERVED_PROPS = { |
| key: true, |
| ref: true, |
| __self: true, |
| __source: true |
| }; |
| |
| /** |
| * Base constructor for all React elements. This is only used to make this |
| * work with a dynamic instanceof check. Nothing should live on this prototype. |
| * |
| * @param {*} type |
| * @param {*} key |
| * @param {string|object} ref |
| * @param {*} self A *temporary* helper to detect places where `this` is |
| * different from the `owner` when React.createElement is called, so that we |
| * can warn. We want to get rid of owner and replace string `ref`s with arrow |
| * functions, and as long as `this` and owner are the same, there will be no |
| * change in behavior. |
| * @param {*} source An annotation object (added by a transpiler or otherwise) |
| * indicating filename, line number, and/or other information. |
| * @param {*} owner |
| * @param {*} props |
| * @internal |
| */ |
| var ReactElement = function (type, key, ref, self, source, owner, props) { |
| var element = { |
| // This tag allow us to uniquely identify this as a React Element |
| $$typeof: REACT_ELEMENT_TYPE, |
| |
| // Built-in properties that belong on the element |
| type: type, |
| key: key, |
| ref: ref, |
| props: props, |
| |
| // Record the component responsible for creating this element. |
| _owner: owner |
| }; |
| |
| if ("development" !== 'production') { |
| // The validation flag is currently mutative. We put it on |
| // an external backing store so that we can freeze the whole object. |
| // This can be replaced with a WeakMap once they are implemented in |
| // commonly used development environments. |
| element._store = {}; |
| |
| // To make comparing ReactElements easier for testing purposes, we make |
| // the validation flag non-enumerable (where possible, which should |
| // include every environment we run tests in), so the test framework |
| // ignores it. |
| if (canDefineProperty) { |
| Object.defineProperty(element._store, 'validated', { |
| configurable: false, |
| enumerable: false, |
| writable: true, |
| value: false |
| }); |
| // self and source are DEV only properties. |
| Object.defineProperty(element, '_self', { |
| configurable: false, |
| enumerable: false, |
| writable: false, |
| value: self |
| }); |
| // Two elements created in two different places should be considered |
| // equal for testing purposes and therefore we hide it from enumeration. |
| Object.defineProperty(element, '_source', { |
| configurable: false, |
| enumerable: false, |
| writable: false, |
| value: source |
| }); |
| } else { |
| element._store.validated = false; |
| element._self = self; |
| element._source = source; |
| } |
| Object.freeze(element.props); |
| Object.freeze(element); |
| } |
| |
| return element; |
| }; |
| |
| ReactElement.createElement = function (type, config, children) { |
| var propName; |
| |
| // Reserved names are extracted |
| var props = {}; |
| |
| var key = null; |
| var ref = null; |
| var self = null; |
| var source = null; |
| |
| if (config != null) { |
| ref = config.ref === undefined ? null : config.ref; |
| key = config.key === undefined ? null : '' + config.key; |
| self = config.__self === undefined ? null : config.__self; |
| source = config.__source === undefined ? null : config.__source; |
| // Remaining properties are added to a new props object |
| for (propName in config) { |
| if (config.hasOwnProperty(propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { |
| props[propName] = config[propName]; |
| } |
| } |
| } |
| |
| // Children can be more than one argument, and those are transferred onto |
| // the newly allocated props object. |
| var childrenLength = arguments.length - 2; |
| if (childrenLength === 1) { |
| props.children = children; |
| } else if (childrenLength > 1) { |
| var childArray = Array(childrenLength); |
| for (var i = 0; i < childrenLength; i++) { |
| childArray[i] = arguments[i + 2]; |
| } |
| props.children = childArray; |
| } |
| |
| // Resolve default props |
| if (type && type.defaultProps) { |
| var defaultProps = type.defaultProps; |
| for (propName in defaultProps) { |
| if (typeof props[propName] === 'undefined') { |
| props[propName] = defaultProps[propName]; |
| } |
| } |
| } |
| |
| return ReactElement(type, key, ref, self, source, ReactCurrentOwner.current, props); |
| }; |
| |
| ReactElement.createFactory = function (type) { |
| var factory = ReactElement.createElement.bind(null, type); |
| // Expose the type on the factory and the prototype so that it can be |
| // easily accessed on elements. E.g. `<Foo />.type === Foo`. |
| // This should not be named `constructor` since this may not be the function |
| // that created the element, and it may not even be a constructor. |
| // Legacy hook TODO: Warn if this is accessed |
| factory.type = type; |
| return factory; |
| }; |
| |
| ReactElement.cloneAndReplaceKey = function (oldElement, newKey) { |
| var newElement = ReactElement(oldElement.type, newKey, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, oldElement.props); |
| |
| return newElement; |
| }; |
| |
| ReactElement.cloneAndReplaceProps = function (oldElement, newProps) { |
| var newElement = ReactElement(oldElement.type, oldElement.key, oldElement.ref, oldElement._self, oldElement._source, oldElement._owner, newProps); |
| |
| if ("development" !== 'production') { |
| // If the key on the original is valid, then the clone is valid |
| newElement._store.validated = oldElement._store.validated; |
| } |
| |
| return newElement; |
| }; |
| |
| ReactElement.cloneElement = function (element, config, children) { |
| var propName; |
| |
| // Original props are copied |
| var props = assign({}, element.props); |
| |
| // Reserved names are extracted |
| var key = element.key; |
| var ref = element.ref; |
| // Self is preserved since the owner is preserved. |
| var self = element._self; |
| // Source is preserved since cloneElement is unlikely to be targeted by a |
| // transpiler, and the original source is probably a better indicator of the |
| // true owner. |
| var source = element._source; |
| |
| // Owner will be preserved, unless ref is overridden |
| var owner = element._owner; |
| |
| if (config != null) { |
| if (config.ref !== undefined) { |
| // Silently steal the ref from the parent. |
| ref = config.ref; |
| owner = ReactCurrentOwner.current; |
| } |
| if (config.key !== undefined) { |
| key = '' + config.key; |
| } |
| // Remaining properties override existing props |
| for (propName in config) { |
| if (config.hasOwnProperty(propName) && !RESERVED_PROPS.hasOwnProperty(propName)) { |
| props[propName] = config[propName]; |
| } |
| } |
| } |
| |
| // Children can be more than one argument, and those are transferred onto |
| // the newly allocated props object. |
| var childrenLength = arguments.length - 2; |
| if (childrenLength === 1) { |
| props.children = children; |
| } else if (childrenLength > 1) { |
| var childArray = Array(childrenLength); |
| for (var i = 0; i < childrenLength; i++) { |
| childArray[i] = arguments[i + 2]; |
| } |
| props.children = childArray; |
| } |
| |
| return ReactElement(element.type, key, ref, self, source, owner, props); |
| }; |
| |
| /** |
| * @param {?object} object |
| * @return {boolean} True if `object` is a valid component. |
| * @final |
| */ |
| ReactElement.isValidElement = function (object) { |
| return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE; |
| }; |
| |
| module.exports = ReactElement; |
| },{"117":117,"24":24,"39":39}],58:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactElementValidator |
| */ |
| |
| /** |
| * ReactElementValidator provides a wrapper around a element factory |
| * which validates the props passed to the element. This is intended to be |
| * used only in DEV and could be replaced by a static type checker for languages |
| * that support it. |
| */ |
| |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| var ReactPropTypeLocations = _dereq_(81); |
| var ReactPropTypeLocationNames = _dereq_(80); |
| var ReactCurrentOwner = _dereq_(39); |
| |
| var canDefineProperty = _dereq_(117); |
| var getIteratorFn = _dereq_(129); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| function getDeclarationErrorAddendum() { |
| if (ReactCurrentOwner.current) { |
| var name = ReactCurrentOwner.current.getName(); |
| if (name) { |
| return ' Check the render method of `' + name + '`.'; |
| } |
| } |
| return ''; |
| } |
| |
| /** |
| * Warn if there's no key explicitly set on dynamic arrays of children or |
| * object keys are not valid. This allows us to keep track of children between |
| * updates. |
| */ |
| var ownerHasKeyUseWarning = {}; |
| |
| var loggedTypeFailures = {}; |
| |
| /** |
| * Warn if the element doesn't have an explicit key assigned to it. |
| * This element is in an array. The array could grow and shrink or be |
| * reordered. All children that haven't already been validated are required to |
| * have a "key" property assigned to it. |
| * |
| * @internal |
| * @param {ReactElement} element Element that requires a key. |
| * @param {*} parentType element's parent's type. |
| */ |
| function validateExplicitKey(element, parentType) { |
| if (!element._store || element._store.validated || element.key != null) { |
| return; |
| } |
| element._store.validated = true; |
| |
| var addenda = getAddendaForKeyUse('uniqueKey', element, parentType); |
| if (addenda === null) { |
| // we already showed the warning |
| return; |
| } |
| "development" !== 'production' ? warning(false, 'Each child in an array or iterator should have a unique "key" prop.' + '%s%s%s', addenda.parentOrOwner || '', addenda.childOwner || '', addenda.url || '') : undefined; |
| } |
| |
| /** |
| * Shared warning and monitoring code for the key warnings. |
| * |
| * @internal |
| * @param {string} messageType A key used for de-duping warnings. |
| * @param {ReactElement} element Component that requires a key. |
| * @param {*} parentType element's parent's type. |
| * @returns {?object} A set of addenda to use in the warning message, or null |
| * if the warning has already been shown before (and shouldn't be shown again). |
| */ |
| function getAddendaForKeyUse(messageType, element, parentType) { |
| var addendum = getDeclarationErrorAddendum(); |
| if (!addendum) { |
| var parentName = typeof parentType === 'string' ? parentType : parentType.displayName || parentType.name; |
| if (parentName) { |
| addendum = ' Check the top-level render call using <' + parentName + '>.'; |
| } |
| } |
| |
| var memoizer = ownerHasKeyUseWarning[messageType] || (ownerHasKeyUseWarning[messageType] = {}); |
| if (memoizer[addendum]) { |
| return null; |
| } |
| memoizer[addendum] = true; |
| |
| var addenda = { |
| parentOrOwner: addendum, |
| url: ' See https://fb.me/react-warning-keys for more information.', |
| childOwner: null |
| }; |
| |
| // Usually the current owner is the offender, but if it accepts children as a |
| // property, it may be the creator of the child that's responsible for |
| // assigning it a key. |
| if (element && element._owner && element._owner !== ReactCurrentOwner.current) { |
| // Give the component that originally created this child. |
| addenda.childOwner = ' It was passed a child from ' + element._owner.getName() + '.'; |
| } |
| |
| return addenda; |
| } |
| |
| /** |
| * Ensure that every element either is passed in a static location, in an |
| * array with an explicit keys property defined, or in an object literal |
| * with valid key property. |
| * |
| * @internal |
| * @param {ReactNode} node Statically passed child of any type. |
| * @param {*} parentType node's parent's type. |
| */ |
| function validateChildKeys(node, parentType) { |
| if (typeof node !== 'object') { |
| return; |
| } |
| if (Array.isArray(node)) { |
| for (var i = 0; i < node.length; i++) { |
| var child = node[i]; |
| if (ReactElement.isValidElement(child)) { |
| validateExplicitKey(child, parentType); |
| } |
| } |
| } else if (ReactElement.isValidElement(node)) { |
| // This element was passed in a valid location. |
| if (node._store) { |
| node._store.validated = true; |
| } |
| } else if (node) { |
| var iteratorFn = getIteratorFn(node); |
| // Entry iterators provide implicit keys. |
| if (iteratorFn) { |
| if (iteratorFn !== node.entries) { |
| var iterator = iteratorFn.call(node); |
| var step; |
| while (!(step = iterator.next()).done) { |
| if (ReactElement.isValidElement(step.value)) { |
| validateExplicitKey(step.value, parentType); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * Assert that the props are valid |
| * |
| * @param {string} componentName Name of the component for error messages. |
| * @param {object} propTypes Map of prop name to a ReactPropType |
| * @param {object} props |
| * @param {string} location e.g. "prop", "context", "child context" |
| * @private |
| */ |
| function checkPropTypes(componentName, propTypes, props, location) { |
| for (var propName in propTypes) { |
| if (propTypes.hasOwnProperty(propName)) { |
| var error; |
| // Prop type validation may throw. In case they do, we don't want to |
| // fail the render phase where it didn't fail before. So we log it. |
| // After these have been cleaned up, we'll let them throw. |
| try { |
| // This is intentionally an invariant that gets caught. It's the same |
| // behavior as without this statement except with a better message. |
| !(typeof propTypes[propName] === 'function') ? "development" !== 'production' ? invariant(false, '%s: %s type `%s` is invalid; it must be a function, usually from ' + 'React.PropTypes.', componentName || 'React class', ReactPropTypeLocationNames[location], propName) : invariant(false) : undefined; |
| error = propTypes[propName](props, propName, componentName, location); |
| } catch (ex) { |
| error = ex; |
| } |
| "development" !== 'production' ? warning(!error || error instanceof Error, '%s: type specification of %s `%s` is invalid; the type checker ' + 'function must return `null` or an `Error` but returned a %s. ' + 'You may have forgotten to pass an argument to the type checker ' + 'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' + 'shape all require an argument).', componentName || 'React class', ReactPropTypeLocationNames[location], propName, typeof error) : undefined; |
| if (error instanceof Error && !(error.message in loggedTypeFailures)) { |
| // Only monitor this failure once because there tends to be a lot of the |
| // same error. |
| loggedTypeFailures[error.message] = true; |
| |
| var addendum = getDeclarationErrorAddendum(); |
| "development" !== 'production' ? warning(false, 'Failed propType: %s%s', error.message, addendum) : undefined; |
| } |
| } |
| } |
| } |
| |
| /** |
| * Given an element, validate that its props follow the propTypes definition, |
| * provided by the type. |
| * |
| * @param {ReactElement} element |
| */ |
| function validatePropTypes(element) { |
| var componentClass = element.type; |
| if (typeof componentClass !== 'function') { |
| return; |
| } |
| var name = componentClass.displayName || componentClass.name; |
| if (componentClass.propTypes) { |
| checkPropTypes(name, componentClass.propTypes, element.props, ReactPropTypeLocations.prop); |
| } |
| if (typeof componentClass.getDefaultProps === 'function') { |
| "development" !== 'production' ? warning(componentClass.getDefaultProps.isReactClassApproved, 'getDefaultProps is only used on classic React.createClass ' + 'definitions. Use a static property named `defaultProps` instead.') : undefined; |
| } |
| } |
| |
| var ReactElementValidator = { |
| |
| createElement: function (type, props, children) { |
| var validType = typeof type === 'string' || typeof type === 'function'; |
| // We warn in this case but don't throw. We expect the element creation to |
| // succeed and there will likely be errors in render. |
| "development" !== 'production' ? warning(validType, 'React.createElement: type should not be null, undefined, boolean, or ' + 'number. It should be a string (for DOM elements) or a ReactClass ' + '(for composite components).%s', getDeclarationErrorAddendum()) : undefined; |
| |
| var element = ReactElement.createElement.apply(this, arguments); |
| |
| // The result can be nullish if a mock or a custom function is used. |
| // TODO: Drop this when these are no longer allowed as the type argument. |
| if (element == null) { |
| return element; |
| } |
| |
| // Skip key warning if the type isn't valid since our key validation logic |
| // doesn't expect a non-string/function type and can throw confusing errors. |
| // We don't want exception behavior to differ between dev and prod. |
| // (Rendering will throw with a helpful message and as soon as the type is |
| // fixed, the key warnings will appear.) |
| if (validType) { |
| for (var i = 2; i < arguments.length; i++) { |
| validateChildKeys(arguments[i], type); |
| } |
| } |
| |
| validatePropTypes(element); |
| |
| return element; |
| }, |
| |
| createFactory: function (type) { |
| var validatedFactory = ReactElementValidator.createElement.bind(null, type); |
| // Legacy hook TODO: Warn if this is accessed |
| validatedFactory.type = type; |
| |
| if ("development" !== 'production') { |
| if (canDefineProperty) { |
| Object.defineProperty(validatedFactory, 'type', { |
| enumerable: false, |
| get: function () { |
| "development" !== 'production' ? warning(false, 'Factory.type is deprecated. Access the class directly ' + 'before passing it to createFactory.') : undefined; |
| Object.defineProperty(this, 'type', { |
| value: type |
| }); |
| return type; |
| } |
| }); |
| } |
| } |
| |
| return validatedFactory; |
| }, |
| |
| cloneElement: function (element, props, children) { |
| var newElement = ReactElement.cloneElement.apply(this, arguments); |
| for (var i = 2; i < arguments.length; i++) { |
| validateChildKeys(arguments[i], newElement.type); |
| } |
| validatePropTypes(newElement); |
| return newElement; |
| } |
| |
| }; |
| |
| module.exports = ReactElementValidator; |
| },{"117":117,"129":129,"161":161,"173":173,"39":39,"57":57,"80":80,"81":81}],59:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactEmptyComponent |
| */ |
| |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| var ReactEmptyComponentRegistry = _dereq_(60); |
| var ReactReconciler = _dereq_(84); |
| |
| var assign = _dereq_(24); |
| |
| var placeholderElement; |
| |
| var ReactEmptyComponentInjection = { |
| injectEmptyComponent: function (component) { |
| placeholderElement = ReactElement.createElement(component); |
| } |
| }; |
| |
| var ReactEmptyComponent = function (instantiate) { |
| this._currentElement = null; |
| this._rootNodeID = null; |
| this._renderedComponent = instantiate(placeholderElement); |
| }; |
| assign(ReactEmptyComponent.prototype, { |
| construct: function (element) {}, |
| mountComponent: function (rootID, transaction, context) { |
| ReactEmptyComponentRegistry.registerNullComponentID(rootID); |
| this._rootNodeID = rootID; |
| return ReactReconciler.mountComponent(this._renderedComponent, rootID, transaction, context); |
| }, |
| receiveComponent: function () {}, |
| unmountComponent: function (rootID, transaction, context) { |
| ReactReconciler.unmountComponent(this._renderedComponent); |
| ReactEmptyComponentRegistry.deregisterNullComponentID(this._rootNodeID); |
| this._rootNodeID = null; |
| this._renderedComponent = null; |
| } |
| }); |
| |
| ReactEmptyComponent.injection = ReactEmptyComponentInjection; |
| |
| module.exports = ReactEmptyComponent; |
| },{"24":24,"57":57,"60":60,"84":84}],60:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactEmptyComponentRegistry |
| */ |
| |
| 'use strict'; |
| |
| // This registry keeps track of the React IDs of the components that rendered to |
| // `null` (in reality a placeholder such as `noscript`) |
| var nullComponentIDsRegistry = {}; |
| |
| /** |
| * @param {string} id Component's `_rootNodeID`. |
| * @return {boolean} True if the component is rendered to null. |
| */ |
| function isNullComponentID(id) { |
| return !!nullComponentIDsRegistry[id]; |
| } |
| |
| /** |
| * Mark the component as having rendered to null. |
| * @param {string} id Component's `_rootNodeID`. |
| */ |
| function registerNullComponentID(id) { |
| nullComponentIDsRegistry[id] = true; |
| } |
| |
| /** |
| * Unmark the component as having rendered to null: it renders to something now. |
| * @param {string} id Component's `_rootNodeID`. |
| */ |
| function deregisterNullComponentID(id) { |
| delete nullComponentIDsRegistry[id]; |
| } |
| |
| var ReactEmptyComponentRegistry = { |
| isNullComponentID: isNullComponentID, |
| registerNullComponentID: registerNullComponentID, |
| deregisterNullComponentID: deregisterNullComponentID |
| }; |
| |
| module.exports = ReactEmptyComponentRegistry; |
| },{}],61:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactErrorUtils |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var caughtError = null; |
| |
| /** |
| * 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 |
| */ |
| function invokeGuardedCallback(name, func, a, b) { |
| try { |
| return func(a, b); |
| } catch (x) { |
| if (caughtError === null) { |
| caughtError = x; |
| } |
| return undefined; |
| } |
| } |
| |
| var ReactErrorUtils = { |
| invokeGuardedCallback: invokeGuardedCallback, |
| |
| /** |
| * Invoked by ReactTestUtils.Simulate so that any errors thrown by the event |
| * handler are sure to be rethrown by rethrowCaughtError. |
| */ |
| invokeGuardedCallbackWithCatch: invokeGuardedCallback, |
| |
| /** |
| * During execution of guarded functions we will capture the first error which |
| * we will rethrow to be handled by the top level error handler. |
| */ |
| rethrowCaughtError: function () { |
| if (caughtError) { |
| var error = caughtError; |
| caughtError = null; |
| throw error; |
| } |
| } |
| }; |
| |
| if ("development" !== 'production') { |
| /** |
| * To help development we can get better devtools integration by simulating a |
| * real browser event. |
| */ |
| if (typeof window !== 'undefined' && typeof window.dispatchEvent === 'function' && typeof document !== 'undefined' && typeof document.createEvent === 'function') { |
| var fakeNode = document.createElement('react'); |
| ReactErrorUtils.invokeGuardedCallback = function (name, func, a, b) { |
| var boundFunc = func.bind(null, a, b); |
| fakeNode.addEventListener(name, boundFunc, false); |
| var evt = document.createEvent('Event'); |
| evt.initEvent(name, false, false); |
| fakeNode.dispatchEvent(evt); |
| fakeNode.removeEventListener(name, boundFunc, false); |
| }; |
| } |
| } |
| |
| module.exports = ReactErrorUtils; |
| },{}],62:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactEventEmitterMixin |
| */ |
| |
| 'use strict'; |
| |
| var EventPluginHub = _dereq_(16); |
| |
| function runEventQueueInBatch(events) { |
| EventPluginHub.enqueueEvents(events); |
| EventPluginHub.processEventQueue(false); |
| } |
| |
| var ReactEventEmitterMixin = { |
| |
| /** |
| * Streams a fired top-level event to `EventPluginHub` where plugins have the |
| * opportunity to create `ReactEvent`s to be dispatched. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {object} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native environment event. |
| */ |
| handleTopLevel: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| var events = EventPluginHub.extractEvents(topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget); |
| runEventQueueInBatch(events); |
| } |
| }; |
| |
| module.exports = ReactEventEmitterMixin; |
| },{"16":16}],63:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactEventListener |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var EventListener = _dereq_(146); |
| var ExecutionEnvironment = _dereq_(147); |
| var PooledClass = _dereq_(25); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactMount = _dereq_(72); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var getEventTarget = _dereq_(128); |
| var getUnboundedScrollPosition = _dereq_(158); |
| |
| var DOCUMENT_FRAGMENT_NODE_TYPE = 11; |
| |
| /** |
| * Finds the parent React component of `node`. |
| * |
| * @param {*} node |
| * @return {?DOMEventTarget} Parent container, or `null` if the specified node |
| * is not nested. |
| */ |
| function findParent(node) { |
| // 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. |
| var nodeID = ReactMount.getID(node); |
| var rootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID); |
| var container = ReactMount.findReactContainerForID(rootID); |
| var parent = ReactMount.getFirstReactDOM(container); |
| return parent; |
| } |
| |
| // Used to store ancestor hierarchy in top level callback |
| function TopLevelCallbackBookKeeping(topLevelType, nativeEvent) { |
| this.topLevelType = topLevelType; |
| this.nativeEvent = nativeEvent; |
| this.ancestors = []; |
| } |
| assign(TopLevelCallbackBookKeeping.prototype, { |
| destructor: function () { |
| this.topLevelType = null; |
| this.nativeEvent = null; |
| this.ancestors.length = 0; |
| } |
| }); |
| PooledClass.addPoolingTo(TopLevelCallbackBookKeeping, PooledClass.twoArgumentPooler); |
| |
| function handleTopLevelImpl(bookKeeping) { |
| // TODO: Re-enable event.path handling |
| // |
| // if (bookKeeping.nativeEvent.path && bookKeeping.nativeEvent.path.length > 1) { |
| // // New browsers have a path attribute on native events |
| // handleTopLevelWithPath(bookKeeping); |
| // } else { |
| // // Legacy browsers don't have a path attribute on native events |
| // handleTopLevelWithoutPath(bookKeeping); |
| // } |
| |
| void handleTopLevelWithPath; // temporarily unused |
| handleTopLevelWithoutPath(bookKeeping); |
| } |
| |
| // Legacy browsers don't have a path attribute on native events |
| function handleTopLevelWithoutPath(bookKeeping) { |
| var topLevelTarget = ReactMount.getFirstReactDOM(getEventTarget(bookKeeping.nativeEvent)) || window; |
| |
| // Loop through the hierarchy, in case there's any nested components. |
| // It's important that we build the array of ancestors before calling any |
| // event handlers, because event handlers can modify the DOM, leading to |
| // inconsistencies with ReactMount's node cache. See #1105. |
| var ancestor = topLevelTarget; |
| while (ancestor) { |
| bookKeeping.ancestors.push(ancestor); |
| ancestor = findParent(ancestor); |
| } |
| |
| for (var i = 0; i < bookKeeping.ancestors.length; i++) { |
| topLevelTarget = bookKeeping.ancestors[i]; |
| var topLevelTargetID = ReactMount.getID(topLevelTarget) || ''; |
| ReactEventListener._handleTopLevel(bookKeeping.topLevelType, topLevelTarget, topLevelTargetID, bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent)); |
| } |
| } |
| |
| // New browsers have a path attribute on native events |
| function handleTopLevelWithPath(bookKeeping) { |
| var path = bookKeeping.nativeEvent.path; |
| var currentNativeTarget = path[0]; |
| var eventsFired = 0; |
| for (var i = 0; i < path.length; i++) { |
| var currentPathElement = path[i]; |
| if (currentPathElement.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE) { |
| currentNativeTarget = path[i + 1]; |
| } |
| // TODO: slow |
| var reactParent = ReactMount.getFirstReactDOM(currentPathElement); |
| if (reactParent === currentPathElement) { |
| var currentPathElementID = ReactMount.getID(currentPathElement); |
| var newRootID = ReactInstanceHandles.getReactRootIDFromNodeID(currentPathElementID); |
| bookKeeping.ancestors.push(currentPathElement); |
| |
| var topLevelTargetID = ReactMount.getID(currentPathElement) || ''; |
| eventsFired++; |
| ReactEventListener._handleTopLevel(bookKeeping.topLevelType, currentPathElement, topLevelTargetID, bookKeeping.nativeEvent, currentNativeTarget); |
| |
| // Jump to the root of this React render tree |
| while (currentPathElementID !== newRootID) { |
| i++; |
| currentPathElement = path[i]; |
| currentPathElementID = ReactMount.getID(currentPathElement); |
| } |
| } |
| } |
| if (eventsFired === 0) { |
| ReactEventListener._handleTopLevel(bookKeeping.topLevelType, window, '', bookKeeping.nativeEvent, getEventTarget(bookKeeping.nativeEvent)); |
| } |
| } |
| |
| function scrollValueMonitor(cb) { |
| var scrollPosition = getUnboundedScrollPosition(window); |
| cb(scrollPosition); |
| } |
| |
| var ReactEventListener = { |
| _enabled: true, |
| _handleTopLevel: null, |
| |
| WINDOW_HANDLE: ExecutionEnvironment.canUseDOM ? window : null, |
| |
| setHandleTopLevel: function (handleTopLevel) { |
| ReactEventListener._handleTopLevel = handleTopLevel; |
| }, |
| |
| setEnabled: function (enabled) { |
| ReactEventListener._enabled = !!enabled; |
| }, |
| |
| isEnabled: function () { |
| return ReactEventListener._enabled; |
| }, |
| |
| /** |
| * Traps top-level events by using event bubbling. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {string} handlerBaseName Event name (e.g. "click"). |
| * @param {object} handle Element on which to attach listener. |
| * @return {?object} An object with a remove function which will forcefully |
| * remove the listener. |
| * @internal |
| */ |
| trapBubbledEvent: function (topLevelType, handlerBaseName, handle) { |
| var element = handle; |
| if (!element) { |
| return null; |
| } |
| return EventListener.listen(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType)); |
| }, |
| |
| /** |
| * Traps a top-level event by using event capturing. |
| * |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {string} handlerBaseName Event name (e.g. "click"). |
| * @param {object} handle Element on which to attach listener. |
| * @return {?object} An object with a remove function which will forcefully |
| * remove the listener. |
| * @internal |
| */ |
| trapCapturedEvent: function (topLevelType, handlerBaseName, handle) { |
| var element = handle; |
| if (!element) { |
| return null; |
| } |
| return EventListener.capture(element, handlerBaseName, ReactEventListener.dispatchEvent.bind(null, topLevelType)); |
| }, |
| |
| monitorScrollValue: function (refresh) { |
| var callback = scrollValueMonitor.bind(null, refresh); |
| EventListener.listen(window, 'scroll', callback); |
| }, |
| |
| dispatchEvent: function (topLevelType, nativeEvent) { |
| if (!ReactEventListener._enabled) { |
| return; |
| } |
| |
| var bookKeeping = TopLevelCallbackBookKeeping.getPooled(topLevelType, nativeEvent); |
| try { |
| // Event queue being processed in the same cycle allows |
| // `preventDefault`. |
| ReactUpdates.batchedUpdates(handleTopLevelImpl, bookKeeping); |
| } finally { |
| TopLevelCallbackBookKeeping.release(bookKeeping); |
| } |
| } |
| }; |
| |
| module.exports = ReactEventListener; |
| },{"128":128,"146":146,"147":147,"158":158,"24":24,"25":25,"67":67,"72":72,"96":96}],64:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactFragment |
| */ |
| |
| 'use strict'; |
| |
| var ReactChildren = _dereq_(32); |
| var ReactElement = _dereq_(57); |
| |
| var emptyFunction = _dereq_(153); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| /** |
| * We used to allow keyed objects to serve as a collection of ReactElements, |
| * or nested sets. This allowed us a way to explicitly key a set a fragment of |
| * components. This is now being replaced with an opaque data structure. |
| * The upgrade path is to call React.addons.createFragment({ key: value }) to |
| * create a keyed fragment. The resulting data structure is an array. |
| */ |
| |
| var numericPropertyRegex = /^\d+$/; |
| |
| var warnedAboutNumeric = false; |
| |
| var ReactFragment = { |
| // Wrap a keyed object in an opaque proxy that warns you if you access any |
| // of its properties. |
| create: function (object) { |
| if (typeof object !== 'object' || !object || Array.isArray(object)) { |
| "development" !== 'production' ? warning(false, 'React.addons.createFragment only accepts a single object. Got: %s', object) : undefined; |
| return object; |
| } |
| if (ReactElement.isValidElement(object)) { |
| "development" !== 'production' ? warning(false, 'React.addons.createFragment does not accept a ReactElement ' + 'without a wrapper object.') : undefined; |
| return object; |
| } |
| |
| !(object.nodeType !== 1) ? "development" !== 'production' ? invariant(false, 'React.addons.createFragment(...): Encountered an invalid child; DOM ' + 'elements are not valid children of React components.') : invariant(false) : undefined; |
| |
| var result = []; |
| |
| for (var key in object) { |
| if ("development" !== 'production') { |
| if (!warnedAboutNumeric && numericPropertyRegex.test(key)) { |
| "development" !== 'production' ? warning(false, 'React.addons.createFragment(...): Child objects should have ' + 'non-numeric keys so ordering is preserved.') : undefined; |
| warnedAboutNumeric = true; |
| } |
| } |
| ReactChildren.mapIntoWithKeyPrefixInternal(object[key], result, key, emptyFunction.thatReturnsArgument); |
| } |
| |
| return result; |
| } |
| }; |
| |
| module.exports = ReactFragment; |
| },{"153":153,"161":161,"173":173,"32":32,"57":57}],65:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactInjection |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| var EventPluginHub = _dereq_(16); |
| var ReactComponentEnvironment = _dereq_(36); |
| var ReactClass = _dereq_(33); |
| var ReactEmptyComponent = _dereq_(59); |
| var ReactBrowserEventEmitter = _dereq_(28); |
| var ReactNativeComponent = _dereq_(75); |
| var ReactPerf = _dereq_(78); |
| var ReactRootIndex = _dereq_(86); |
| var ReactUpdates = _dereq_(96); |
| |
| var ReactInjection = { |
| Component: ReactComponentEnvironment.injection, |
| Class: ReactClass.injection, |
| DOMProperty: DOMProperty.injection, |
| EmptyComponent: ReactEmptyComponent.injection, |
| EventPluginHub: EventPluginHub.injection, |
| EventEmitter: ReactBrowserEventEmitter.injection, |
| NativeComponent: ReactNativeComponent.injection, |
| Perf: ReactPerf.injection, |
| RootIndex: ReactRootIndex.injection, |
| Updates: ReactUpdates.injection |
| }; |
| |
| module.exports = ReactInjection; |
| },{"10":10,"16":16,"28":28,"33":33,"36":36,"59":59,"75":75,"78":78,"86":86,"96":96}],66:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactInputSelection |
| */ |
| |
| 'use strict'; |
| |
| var ReactDOMSelection = _dereq_(49); |
| |
| var containsNode = _dereq_(150); |
| var focusNode = _dereq_(155); |
| var getActiveElement = _dereq_(156); |
| |
| function isInDocument(node) { |
| return containsNode(document.documentElement, node); |
| } |
| |
| /** |
| * @ReactInputSelection: React input selection module. Based on Selection.js, |
| * but modified to be suitable for react and has a couple of bug fixes (doesn't |
| * assume buttons have range selections allowed). |
| * Input selection module for React. |
| */ |
| var ReactInputSelection = { |
| |
| hasSelectionCapabilities: function (elem) { |
| var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase(); |
| return nodeName && (nodeName === 'input' && elem.type === 'text' || nodeName === 'textarea' || elem.contentEditable === 'true'); |
| }, |
| |
| getSelectionInformation: function () { |
| var focusedElem = getActiveElement(); |
| return { |
| focusedElem: focusedElem, |
| selectionRange: ReactInputSelection.hasSelectionCapabilities(focusedElem) ? ReactInputSelection.getSelection(focusedElem) : null |
| }; |
| }, |
| |
| /** |
| * @restoreSelection: If any selection information was potentially lost, |
| * restore it. This is useful when performing operations that could remove dom |
| * nodes and place them back in, resulting in focus being lost. |
| */ |
| restoreSelection: function (priorSelectionInformation) { |
| var curFocusedElem = getActiveElement(); |
| var priorFocusedElem = priorSelectionInformation.focusedElem; |
| var priorSelectionRange = priorSelectionInformation.selectionRange; |
| if (curFocusedElem !== priorFocusedElem && isInDocument(priorFocusedElem)) { |
| if (ReactInputSelection.hasSelectionCapabilities(priorFocusedElem)) { |
| ReactInputSelection.setSelection(priorFocusedElem, priorSelectionRange); |
| } |
| focusNode(priorFocusedElem); |
| } |
| }, |
| |
| /** |
| * @getSelection: Gets the selection bounds of a focused textarea, input or |
| * contentEditable node. |
| * -@input: Look up selection bounds of this input |
| * -@return {start: selectionStart, end: selectionEnd} |
| */ |
| getSelection: function (input) { |
| var selection; |
| |
| if ('selectionStart' in input) { |
| // Modern browser with input or textarea. |
| selection = { |
| start: input.selectionStart, |
| end: input.selectionEnd |
| }; |
| } else if (document.selection && (input.nodeName && input.nodeName.toLowerCase() === 'input')) { |
| // IE8 input. |
| var range = document.selection.createRange(); |
| // There can only be one selection per document in IE, so it must |
| // be in our element. |
| if (range.parentElement() === input) { |
| selection = { |
| start: -range.moveStart('character', -input.value.length), |
| end: -range.moveEnd('character', -input.value.length) |
| }; |
| } |
| } else { |
| // Content editable or old IE textarea. |
| selection = ReactDOMSelection.getOffsets(input); |
| } |
| |
| return selection || { start: 0, end: 0 }; |
| }, |
| |
| /** |
| * @setSelection: Sets the selection bounds of a textarea or input and focuses |
| * the input. |
| * -@input Set selection bounds of this input or textarea |
| * -@offsets Object of same form that is returned from get* |
| */ |
| setSelection: function (input, offsets) { |
| var start = offsets.start; |
| var end = offsets.end; |
| if (typeof end === 'undefined') { |
| end = start; |
| } |
| |
| if ('selectionStart' in input) { |
| input.selectionStart = start; |
| input.selectionEnd = Math.min(end, input.value.length); |
| } else if (document.selection && (input.nodeName && input.nodeName.toLowerCase() === 'input')) { |
| var range = input.createTextRange(); |
| range.collapse(true); |
| range.moveStart('character', start); |
| range.moveEnd('character', end - start); |
| range.select(); |
| } else { |
| ReactDOMSelection.setOffsets(input, offsets); |
| } |
| } |
| }; |
| |
| module.exports = ReactInputSelection; |
| },{"150":150,"155":155,"156":156,"49":49}],67:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactInstanceHandles |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactRootIndex = _dereq_(86); |
| |
| var invariant = _dereq_(161); |
| |
| var SEPARATOR = '.'; |
| var SEPARATOR_LENGTH = SEPARATOR.length; |
| |
| /** |
| * Maximum depth of traversals before we consider the possibility of a bad ID. |
| */ |
| var MAX_TREE_DEPTH = 10000; |
| |
| /** |
| * Creates a DOM ID prefix to use when mounting React components. |
| * |
| * @param {number} index A unique integer |
| * @return {string} React root ID. |
| * @internal |
| */ |
| function getReactRootIDString(index) { |
| return SEPARATOR + index.toString(36); |
| } |
| |
| /** |
| * Checks if a character in the supplied ID is a separator or the end. |
| * |
| * @param {string} id A React DOM ID. |
| * @param {number} index Index of the character to check. |
| * @return {boolean} True if the character is a separator or end of the ID. |
| * @private |
| */ |
| function isBoundary(id, index) { |
| return id.charAt(index) === SEPARATOR || index === id.length; |
| } |
| |
| /** |
| * Checks if the supplied string is a valid React DOM ID. |
| * |
| * @param {string} id A React DOM ID, maybe. |
| * @return {boolean} True if the string is a valid React DOM ID. |
| * @private |
| */ |
| function isValidID(id) { |
| return id === '' || id.charAt(0) === SEPARATOR && id.charAt(id.length - 1) !== SEPARATOR; |
| } |
| |
| /** |
| * Checks if the first ID is an ancestor of or equal to the second ID. |
| * |
| * @param {string} ancestorID |
| * @param {string} descendantID |
| * @return {boolean} True if `ancestorID` is an ancestor of `descendantID`. |
| * @internal |
| */ |
| function isAncestorIDOf(ancestorID, descendantID) { |
| return descendantID.indexOf(ancestorID) === 0 && isBoundary(descendantID, ancestorID.length); |
| } |
| |
| /** |
| * Gets the parent ID of the supplied React DOM ID, `id`. |
| * |
| * @param {string} id ID of a component. |
| * @return {string} ID of the parent, or an empty string. |
| * @private |
| */ |
| function getParentID(id) { |
| return id ? id.substr(0, id.lastIndexOf(SEPARATOR)) : ''; |
| } |
| |
| /** |
| * Gets the next DOM ID on the tree path from the supplied `ancestorID` to the |
| * supplied `destinationID`. If they are equal, the ID is returned. |
| * |
| * @param {string} ancestorID ID of an ancestor node of `destinationID`. |
| * @param {string} destinationID ID of the destination node. |
| * @return {string} Next ID on the path from `ancestorID` to `destinationID`. |
| * @private |
| */ |
| function getNextDescendantID(ancestorID, destinationID) { |
| !(isValidID(ancestorID) && isValidID(destinationID)) ? "development" !== 'production' ? invariant(false, 'getNextDescendantID(%s, %s): Received an invalid React DOM ID.', ancestorID, destinationID) : invariant(false) : undefined; |
| !isAncestorIDOf(ancestorID, destinationID) ? "development" !== 'production' ? invariant(false, 'getNextDescendantID(...): React has made an invalid assumption about ' + 'the DOM hierarchy. Expected `%s` to be an ancestor of `%s`.', ancestorID, destinationID) : invariant(false) : undefined; |
| if (ancestorID === destinationID) { |
| return ancestorID; |
| } |
| // Skip over the ancestor and the immediate separator. Traverse until we hit |
| // another separator or we reach the end of `destinationID`. |
| var start = ancestorID.length + SEPARATOR_LENGTH; |
| var i; |
| for (i = start; i < destinationID.length; i++) { |
| if (isBoundary(destinationID, i)) { |
| break; |
| } |
| } |
| return destinationID.substr(0, i); |
| } |
| |
| /** |
| * Gets the nearest common ancestor ID of two IDs. |
| * |
| * Using this ID scheme, the nearest common ancestor ID is the longest common |
| * prefix of the two IDs that immediately preceded a "marker" in both strings. |
| * |
| * @param {string} oneID |
| * @param {string} twoID |
| * @return {string} Nearest common ancestor ID, or the empty string if none. |
| * @private |
| */ |
| function getFirstCommonAncestorID(oneID, twoID) { |
| var minLength = Math.min(oneID.length, twoID.length); |
| if (minLength === 0) { |
| return ''; |
| } |
| var lastCommonMarkerIndex = 0; |
| // Use `<=` to traverse until the "EOL" of the shorter string. |
| for (var i = 0; i <= minLength; i++) { |
| if (isBoundary(oneID, i) && isBoundary(twoID, i)) { |
| lastCommonMarkerIndex = i; |
| } else if (oneID.charAt(i) !== twoID.charAt(i)) { |
| break; |
| } |
| } |
| var longestCommonID = oneID.substr(0, lastCommonMarkerIndex); |
| !isValidID(longestCommonID) ? "development" !== 'production' ? invariant(false, 'getFirstCommonAncestorID(%s, %s): Expected a valid React DOM ID: %s', oneID, twoID, longestCommonID) : invariant(false) : undefined; |
| return longestCommonID; |
| } |
| |
| /** |
| * Traverses the parent path between two IDs (either up or down). The IDs must |
| * not be the same, and there must exist a parent path between them. If the |
| * callback returns `false`, traversal is stopped. |
| * |
| * @param {?string} start ID at which to start traversal. |
| * @param {?string} stop ID at which to end traversal. |
| * @param {function} cb Callback to invoke each ID with. |
| * @param {*} arg Argument to invoke the callback with. |
| * @param {?boolean} skipFirst Whether or not to skip the first node. |
| * @param {?boolean} skipLast Whether or not to skip the last node. |
| * @private |
| */ |
| function traverseParentPath(start, stop, cb, arg, skipFirst, skipLast) { |
| start = start || ''; |
| stop = stop || ''; |
| !(start !== stop) ? "development" !== 'production' ? invariant(false, 'traverseParentPath(...): Cannot traverse from and to the same ID, `%s`.', start) : invariant(false) : undefined; |
| var traverseUp = isAncestorIDOf(stop, start); |
| !(traverseUp || isAncestorIDOf(start, stop)) ? "development" !== 'production' ? invariant(false, 'traverseParentPath(%s, %s, ...): Cannot traverse from two IDs that do ' + 'not have a parent path.', start, stop) : invariant(false) : undefined; |
| // Traverse from `start` to `stop` one depth at a time. |
| var depth = 0; |
| var traverse = traverseUp ? getParentID : getNextDescendantID; |
| for (var id = start;; /* until break */id = traverse(id, stop)) { |
| var ret; |
| if ((!skipFirst || id !== start) && (!skipLast || id !== stop)) { |
| ret = cb(id, traverseUp, arg); |
| } |
| if (ret === false || id === stop) { |
| // Only break //after// visiting `stop`. |
| break; |
| } |
| !(depth++ < MAX_TREE_DEPTH) ? "development" !== 'production' ? invariant(false, 'traverseParentPath(%s, %s, ...): Detected an infinite loop while ' + 'traversing the React DOM ID tree. This may be due to malformed IDs: %s', start, stop, id) : invariant(false) : undefined; |
| } |
| } |
| |
| /** |
| * Manages the IDs assigned to DOM representations of React components. This |
| * uses a specific scheme in order to traverse the DOM efficiently (e.g. in |
| * order to simulate events). |
| * |
| * @internal |
| */ |
| var ReactInstanceHandles = { |
| |
| /** |
| * Constructs a React root ID |
| * @return {string} A React root ID. |
| */ |
| createReactRootID: function () { |
| return getReactRootIDString(ReactRootIndex.createReactRootIndex()); |
| }, |
| |
| /** |
| * Constructs a React ID by joining a root ID with a name. |
| * |
| * @param {string} rootID Root ID of a parent component. |
| * @param {string} name A component's name (as flattened children). |
| * @return {string} A React ID. |
| * @internal |
| */ |
| createReactID: function (rootID, name) { |
| return rootID + name; |
| }, |
| |
| /** |
| * Gets the DOM ID of the React component that is the root of the tree that |
| * contains the React component with the supplied DOM ID. |
| * |
| * @param {string} id DOM ID of a React component. |
| * @return {?string} DOM ID of the React component that is the root. |
| * @internal |
| */ |
| getReactRootIDFromNodeID: function (id) { |
| if (id && id.charAt(0) === SEPARATOR && id.length > 1) { |
| var index = id.indexOf(SEPARATOR, 1); |
| return index > -1 ? id.substr(0, index) : id; |
| } |
| return null; |
| }, |
| |
| /** |
| * Traverses the ID hierarchy and invokes the supplied `cb` on any IDs that |
| * should would receive a `mouseEnter` or `mouseLeave` event. |
| * |
| * NOTE: Does not invoke the callback on the nearest common ancestor because |
| * nothing "entered" or "left" that element. |
| * |
| * @param {string} leaveID ID being left. |
| * @param {string} enterID ID being entered. |
| * @param {function} cb Callback to invoke on each entered/left ID. |
| * @param {*} upArg Argument to invoke the callback with on left IDs. |
| * @param {*} downArg Argument to invoke the callback with on entered IDs. |
| * @internal |
| */ |
| traverseEnterLeave: function (leaveID, enterID, cb, upArg, downArg) { |
| var ancestorID = getFirstCommonAncestorID(leaveID, enterID); |
| if (ancestorID !== leaveID) { |
| traverseParentPath(leaveID, ancestorID, cb, upArg, false, true); |
| } |
| if (ancestorID !== enterID) { |
| traverseParentPath(ancestorID, enterID, cb, downArg, true, false); |
| } |
| }, |
| |
| /** |
| * Simulates the traversal of a two-phase, capture/bubble event dispatch. |
| * |
| * NOTE: This traversal happens on IDs without touching the DOM. |
| * |
| * @param {string} targetID ID of the target node. |
| * @param {function} cb Callback to invoke. |
| * @param {*} arg Argument to invoke the callback with. |
| * @internal |
| */ |
| traverseTwoPhase: function (targetID, cb, arg) { |
| if (targetID) { |
| traverseParentPath('', targetID, cb, arg, true, false); |
| traverseParentPath(targetID, '', cb, arg, false, true); |
| } |
| }, |
| |
| /** |
| * Same as `traverseTwoPhase` but skips the `targetID`. |
| */ |
| traverseTwoPhaseSkipTarget: function (targetID, cb, arg) { |
| if (targetID) { |
| traverseParentPath('', targetID, cb, arg, true, true); |
| traverseParentPath(targetID, '', cb, arg, true, true); |
| } |
| }, |
| |
| /** |
| * Traverse a node ID, calling the supplied `cb` for each ancestor ID. For |
| * example, passing `.0.$row-0.1` would result in `cb` getting called |
| * with `.0`, `.0.$row-0`, and `.0.$row-0.1`. |
| * |
| * NOTE: This traversal happens on IDs without touching the DOM. |
| * |
| * @param {string} targetID ID of the target node. |
| * @param {function} cb Callback to invoke. |
| * @param {*} arg Argument to invoke the callback with. |
| * @internal |
| */ |
| traverseAncestors: function (targetID, cb, arg) { |
| traverseParentPath('', targetID, cb, arg, true, false); |
| }, |
| |
| getFirstCommonAncestorID: getFirstCommonAncestorID, |
| |
| /** |
| * Exposed for unit testing. |
| * @private |
| */ |
| _getNextDescendantID: getNextDescendantID, |
| |
| isAncestorIDOf: isAncestorIDOf, |
| |
| SEPARATOR: SEPARATOR |
| |
| }; |
| |
| module.exports = ReactInstanceHandles; |
| },{"161":161,"86":86}],68:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactInstanceMap |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * `ReactInstanceMap` maintains a mapping from a public facing stateful |
| * instance (key) and the internal representation (value). This allows public |
| * methods to accept the user facing instance as an argument and map them back |
| * to internal methods. |
| */ |
| |
| // TODO: Replace this with ES6: var ReactInstanceMap = new Map(); |
| var ReactInstanceMap = { |
| |
| /** |
| * This API should be called `delete` but we'd have to make sure to always |
| * transform these to strings for IE support. When this transform is fully |
| * supported we can rename it. |
| */ |
| remove: function (key) { |
| key._reactInternalInstance = undefined; |
| }, |
| |
| get: function (key) { |
| return key._reactInternalInstance; |
| }, |
| |
| has: function (key) { |
| return key._reactInternalInstance !== undefined; |
| }, |
| |
| set: function (key, value) { |
| key._reactInternalInstance = value; |
| } |
| |
| }; |
| |
| module.exports = ReactInstanceMap; |
| },{}],69:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactIsomorphic |
| */ |
| |
| 'use strict'; |
| |
| var ReactChildren = _dereq_(32); |
| var ReactComponent = _dereq_(34); |
| var ReactClass = _dereq_(33); |
| var ReactDOMFactories = _dereq_(43); |
| var ReactElement = _dereq_(57); |
| var ReactElementValidator = _dereq_(58); |
| var ReactPropTypes = _dereq_(82); |
| var ReactVersion = _dereq_(97); |
| |
| var assign = _dereq_(24); |
| var onlyChild = _dereq_(135); |
| |
| var createElement = ReactElement.createElement; |
| var createFactory = ReactElement.createFactory; |
| var cloneElement = ReactElement.cloneElement; |
| |
| if ("development" !== 'production') { |
| createElement = ReactElementValidator.createElement; |
| createFactory = ReactElementValidator.createFactory; |
| cloneElement = ReactElementValidator.cloneElement; |
| } |
| |
| var React = { |
| |
| // Modern |
| |
| Children: { |
| map: ReactChildren.map, |
| forEach: ReactChildren.forEach, |
| count: ReactChildren.count, |
| toArray: ReactChildren.toArray, |
| only: onlyChild |
| }, |
| |
| Component: ReactComponent, |
| |
| createElement: createElement, |
| cloneElement: cloneElement, |
| isValidElement: ReactElement.isValidElement, |
| |
| // Classic |
| |
| PropTypes: ReactPropTypes, |
| createClass: ReactClass.createClass, |
| createFactory: createFactory, |
| createMixin: function (mixin) { |
| // Currently a noop. Will be used to validate and trace mixins. |
| return mixin; |
| }, |
| |
| // This looks DOM specific but these are actually isomorphic helpers |
| // since they are just generating DOM strings. |
| DOM: ReactDOMFactories, |
| |
| version: ReactVersion, |
| |
| // Hook for JSX spread, don't use this for anything else. |
| __spread: assign |
| }; |
| |
| module.exports = React; |
| },{"135":135,"24":24,"32":32,"33":33,"34":34,"43":43,"57":57,"58":58,"82":82,"97":97}],70:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactLink |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * ReactLink encapsulates a common pattern in which a component wants to modify |
| * a prop received from its parent. ReactLink allows the parent to pass down a |
| * value coupled with a callback that, when invoked, expresses an intent to |
| * modify that value. For example: |
| * |
| * React.createClass({ |
| * getInitialState: function() { |
| * return {value: ''}; |
| * }, |
| * render: function() { |
| * var valueLink = new ReactLink(this.state.value, this._handleValueChange); |
| * return <input valueLink={valueLink} />; |
| * }, |
| * _handleValueChange: function(newValue) { |
| * this.setState({value: newValue}); |
| * } |
| * }); |
| * |
| * We have provided some sugary mixins to make the creation and |
| * consumption of ReactLink easier; see LinkedValueUtils and LinkedStateMixin. |
| */ |
| |
| var React = _dereq_(26); |
| |
| /** |
| * @param {*} value current value of the link |
| * @param {function} requestChange callback to request a change |
| */ |
| function ReactLink(value, requestChange) { |
| this.value = value; |
| this.requestChange = requestChange; |
| } |
| |
| /** |
| * Creates a PropType that enforces the ReactLink API and optionally checks the |
| * type of the value being passed inside the link. Example: |
| * |
| * MyComponent.propTypes = { |
| * tabIndexLink: ReactLink.PropTypes.link(React.PropTypes.number) |
| * } |
| */ |
| function createLinkTypeChecker(linkType) { |
| var shapes = { |
| value: typeof linkType === 'undefined' ? React.PropTypes.any.isRequired : linkType.isRequired, |
| requestChange: React.PropTypes.func.isRequired |
| }; |
| return React.PropTypes.shape(shapes); |
| } |
| |
| ReactLink.PropTypes = { |
| link: createLinkTypeChecker |
| }; |
| |
| module.exports = ReactLink; |
| },{"26":26}],71:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactMarkupChecksum |
| */ |
| |
| 'use strict'; |
| |
| var adler32 = _dereq_(116); |
| |
| var TAG_END = /\/?>/; |
| |
| var ReactMarkupChecksum = { |
| CHECKSUM_ATTR_NAME: 'data-react-checksum', |
| |
| /** |
| * @param {string} markup Markup string |
| * @return {string} Markup string with checksum attribute attached |
| */ |
| addChecksumToMarkup: function (markup) { |
| var checksum = adler32(markup); |
| |
| // Add checksum (handle both parent tags and self-closing tags) |
| return markup.replace(TAG_END, ' ' + ReactMarkupChecksum.CHECKSUM_ATTR_NAME + '="' + checksum + '"$&'); |
| }, |
| |
| /** |
| * @param {string} markup to use |
| * @param {DOMElement} element root React element |
| * @returns {boolean} whether or not the markup is the same |
| */ |
| canReuseMarkup: function (markup, element) { |
| var existingChecksum = element.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME); |
| existingChecksum = existingChecksum && parseInt(existingChecksum, 10); |
| var markupChecksum = adler32(markup); |
| return markupChecksum === existingChecksum; |
| } |
| }; |
| |
| module.exports = ReactMarkupChecksum; |
| },{"116":116}],72:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactMount |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| var ReactBrowserEventEmitter = _dereq_(28); |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactDOMFeatureFlags = _dereq_(44); |
| var ReactElement = _dereq_(57); |
| var ReactEmptyComponentRegistry = _dereq_(60); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactInstanceMap = _dereq_(68); |
| var ReactMarkupChecksum = _dereq_(71); |
| var ReactPerf = _dereq_(78); |
| var ReactReconciler = _dereq_(84); |
| var ReactUpdateQueue = _dereq_(95); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var emptyObject = _dereq_(154); |
| var containsNode = _dereq_(150); |
| var instantiateReactComponent = _dereq_(132); |
| var invariant = _dereq_(161); |
| var setInnerHTML = _dereq_(138); |
| var shouldUpdateReactComponent = _dereq_(141); |
| var validateDOMNesting = _dereq_(144); |
| var warning = _dereq_(173); |
| |
| var ATTR_NAME = DOMProperty.ID_ATTRIBUTE_NAME; |
| var nodeCache = {}; |
| |
| var ELEMENT_NODE_TYPE = 1; |
| var DOC_NODE_TYPE = 9; |
| var DOCUMENT_FRAGMENT_NODE_TYPE = 11; |
| |
| var ownerDocumentContextKey = '__ReactMount_ownerDocument$' + Math.random().toString(36).slice(2); |
| |
| /** Mapping from reactRootID to React component instance. */ |
| var instancesByReactRootID = {}; |
| |
| /** Mapping from reactRootID to `container` nodes. */ |
| var containersByReactRootID = {}; |
| |
| if ("development" !== 'production') { |
| /** __DEV__-only mapping from reactRootID to root elements. */ |
| var rootElementsByReactRootID = {}; |
| } |
| |
| // Used to store breadth-first search state in findComponentRoot. |
| var findComponentRootReusableArray = []; |
| |
| /** |
| * Finds the index of the first character |
| * that's not common between the two given strings. |
| * |
| * @return {number} the index of the character where the strings diverge |
| */ |
| function firstDifferenceIndex(string1, string2) { |
| var minLen = Math.min(string1.length, string2.length); |
| for (var i = 0; i < minLen; i++) { |
| if (string1.charAt(i) !== string2.charAt(i)) { |
| return i; |
| } |
| } |
| return string1.length === string2.length ? -1 : minLen; |
| } |
| |
| /** |
| * @param {DOMElement|DOMDocument} container DOM element that may contain |
| * a React component |
| * @return {?*} DOM element that may have the reactRoot ID, or null. |
| */ |
| function getReactRootElementInContainer(container) { |
| if (!container) { |
| return null; |
| } |
| |
| if (container.nodeType === DOC_NODE_TYPE) { |
| return container.documentElement; |
| } else { |
| return container.firstChild; |
| } |
| } |
| |
| /** |
| * @param {DOMElement} container DOM element that may contain a React component. |
| * @return {?string} A "reactRoot" ID, if a React component is rendered. |
| */ |
| function getReactRootID(container) { |
| var rootElement = getReactRootElementInContainer(container); |
| return rootElement && ReactMount.getID(rootElement); |
| } |
| |
| /** |
| * Accessing node[ATTR_NAME] or calling getAttribute(ATTR_NAME) on a form |
| * element can return its control whose name or ID equals ATTR_NAME. All |
| * DOM nodes support `getAttributeNode` but this can also get called on |
| * other objects so just return '' if we're given something other than a |
| * DOM node (such as window). |
| * |
| * @param {?DOMElement|DOMWindow|DOMDocument|DOMTextNode} node DOM node. |
| * @return {string} ID of the supplied `domNode`. |
| */ |
| function getID(node) { |
| var id = internalGetID(node); |
| if (id) { |
| if (nodeCache.hasOwnProperty(id)) { |
| var cached = nodeCache[id]; |
| if (cached !== node) { |
| !!isValid(cached, id) ? "development" !== 'production' ? invariant(false, 'ReactMount: Two valid but unequal nodes with the same `%s`: %s', ATTR_NAME, id) : invariant(false) : undefined; |
| |
| nodeCache[id] = node; |
| } |
| } else { |
| nodeCache[id] = node; |
| } |
| } |
| |
| return id; |
| } |
| |
| function internalGetID(node) { |
| // If node is something like a window, document, or text node, none of |
| // which support attributes or a .getAttribute method, gracefully return |
| // the empty string, as if the attribute were missing. |
| return node && node.getAttribute && node.getAttribute(ATTR_NAME) || ''; |
| } |
| |
| /** |
| * Sets the React-specific ID of the given node. |
| * |
| * @param {DOMElement} node The DOM node whose ID will be set. |
| * @param {string} id The value of the ID attribute. |
| */ |
| function setID(node, id) { |
| var oldID = internalGetID(node); |
| if (oldID !== id) { |
| delete nodeCache[oldID]; |
| } |
| node.setAttribute(ATTR_NAME, id); |
| nodeCache[id] = node; |
| } |
| |
| /** |
| * Finds the node with the supplied React-generated DOM ID. |
| * |
| * @param {string} id A React-generated DOM ID. |
| * @return {DOMElement} DOM node with the suppled `id`. |
| * @internal |
| */ |
| function getNode(id) { |
| if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) { |
| nodeCache[id] = ReactMount.findReactNodeByID(id); |
| } |
| return nodeCache[id]; |
| } |
| |
| /** |
| * Finds the node with the supplied public React instance. |
| * |
| * @param {*} instance A public React instance. |
| * @return {?DOMElement} DOM node with the suppled `id`. |
| * @internal |
| */ |
| function getNodeFromInstance(instance) { |
| var id = ReactInstanceMap.get(instance)._rootNodeID; |
| if (ReactEmptyComponentRegistry.isNullComponentID(id)) { |
| return null; |
| } |
| if (!nodeCache.hasOwnProperty(id) || !isValid(nodeCache[id], id)) { |
| nodeCache[id] = ReactMount.findReactNodeByID(id); |
| } |
| return nodeCache[id]; |
| } |
| |
| /** |
| * A node is "valid" if it is contained by a currently mounted container. |
| * |
| * This means that the node does not have to be contained by a document in |
| * order to be considered valid. |
| * |
| * @param {?DOMElement} node The candidate DOM node. |
| * @param {string} id The expected ID of the node. |
| * @return {boolean} Whether the node is contained by a mounted container. |
| */ |
| function isValid(node, id) { |
| if (node) { |
| !(internalGetID(node) === id) ? "development" !== 'production' ? invariant(false, 'ReactMount: Unexpected modification of `%s`', ATTR_NAME) : invariant(false) : undefined; |
| |
| var container = ReactMount.findReactContainerForID(id); |
| if (container && containsNode(container, node)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Causes the cache to forget about one React-specific ID. |
| * |
| * @param {string} id The ID to forget. |
| */ |
| function purgeID(id) { |
| delete nodeCache[id]; |
| } |
| |
| var deepestNodeSoFar = null; |
| function findDeepestCachedAncestorImpl(ancestorID) { |
| var ancestor = nodeCache[ancestorID]; |
| if (ancestor && isValid(ancestor, ancestorID)) { |
| deepestNodeSoFar = ancestor; |
| } else { |
| // This node isn't populated in the cache, so presumably none of its |
| // descendants are. Break out of the loop. |
| return false; |
| } |
| } |
| |
| /** |
| * Return the deepest cached node whose ID is a prefix of `targetID`. |
| */ |
| function findDeepestCachedAncestor(targetID) { |
| deepestNodeSoFar = null; |
| ReactInstanceHandles.traverseAncestors(targetID, findDeepestCachedAncestorImpl); |
| |
| var foundNode = deepestNodeSoFar; |
| deepestNodeSoFar = null; |
| return foundNode; |
| } |
| |
| /** |
| * Mounts this component and inserts it into the DOM. |
| * |
| * @param {ReactComponent} componentInstance The instance to mount. |
| * @param {string} rootID DOM ID of the root node. |
| * @param {DOMElement} container DOM element to mount into. |
| * @param {ReactReconcileTransaction} transaction |
| * @param {boolean} shouldReuseMarkup If true, do not insert markup |
| */ |
| function mountComponentIntoNode(componentInstance, rootID, container, transaction, shouldReuseMarkup, context) { |
| if (ReactDOMFeatureFlags.useCreateElement) { |
| context = assign({}, context); |
| if (container.nodeType === DOC_NODE_TYPE) { |
| context[ownerDocumentContextKey] = container; |
| } else { |
| context[ownerDocumentContextKey] = container.ownerDocument; |
| } |
| } |
| if ("development" !== 'production') { |
| if (context === emptyObject) { |
| context = {}; |
| } |
| var tag = container.nodeName.toLowerCase(); |
| context[validateDOMNesting.ancestorInfoContextKey] = validateDOMNesting.updatedAncestorInfo(null, tag, null); |
| } |
| var markup = ReactReconciler.mountComponent(componentInstance, rootID, transaction, context); |
| componentInstance._renderedComponent._topLevelWrapper = componentInstance; |
| ReactMount._mountImageIntoNode(markup, container, shouldReuseMarkup, transaction); |
| } |
| |
| /** |
| * Batched mount. |
| * |
| * @param {ReactComponent} componentInstance The instance to mount. |
| * @param {string} rootID DOM ID of the root node. |
| * @param {DOMElement} container DOM element to mount into. |
| * @param {boolean} shouldReuseMarkup If true, do not insert markup |
| */ |
| function batchedMountComponentIntoNode(componentInstance, rootID, container, shouldReuseMarkup, context) { |
| var transaction = ReactUpdates.ReactReconcileTransaction.getPooled( |
| /* forceHTML */shouldReuseMarkup); |
| transaction.perform(mountComponentIntoNode, null, componentInstance, rootID, container, transaction, shouldReuseMarkup, context); |
| ReactUpdates.ReactReconcileTransaction.release(transaction); |
| } |
| |
| /** |
| * Unmounts a component and removes it from the DOM. |
| * |
| * @param {ReactComponent} instance React component instance. |
| * @param {DOMElement} container DOM element to unmount from. |
| * @final |
| * @internal |
| * @see {ReactMount.unmountComponentAtNode} |
| */ |
| function unmountComponentFromNode(instance, container) { |
| ReactReconciler.unmountComponent(instance); |
| |
| if (container.nodeType === DOC_NODE_TYPE) { |
| container = container.documentElement; |
| } |
| |
| // http://jsperf.com/emptying-a-node |
| while (container.lastChild) { |
| container.removeChild(container.lastChild); |
| } |
| } |
| |
| /** |
| * True if the supplied DOM node has a direct React-rendered child that is |
| * not a React root element. Useful for warning in `render`, |
| * `unmountComponentAtNode`, etc. |
| * |
| * @param {?DOMElement} node The candidate DOM node. |
| * @return {boolean} True if the DOM element contains a direct child that was |
| * rendered by React but is not a root element. |
| * @internal |
| */ |
| function hasNonRootReactChild(node) { |
| var reactRootID = getReactRootID(node); |
| return reactRootID ? reactRootID !== ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID) : false; |
| } |
| |
| /** |
| * Returns the first (deepest) ancestor of a node which is rendered by this copy |
| * of React. |
| */ |
| function findFirstReactDOMImpl(node) { |
| // This node might be from another React instance, so we make sure not to |
| // examine the node cache here |
| for (; node && node.parentNode !== node; node = node.parentNode) { |
| if (node.nodeType !== 1) { |
| // Not a DOMElement, therefore not a React component |
| continue; |
| } |
| var nodeID = internalGetID(node); |
| if (!nodeID) { |
| continue; |
| } |
| var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(nodeID); |
| |
| // If containersByReactRootID contains the container we find by crawling up |
| // the tree, we know that this instance of React rendered the node. |
| // nb. isValid's strategy (with containsNode) does not work because render |
| // trees may be nested and we don't want a false positive in that case. |
| var current = node; |
| var lastID; |
| do { |
| lastID = internalGetID(current); |
| current = current.parentNode; |
| if (current == null) { |
| // The passed-in node has been detached from the container it was |
| // originally rendered into. |
| return null; |
| } |
| } while (lastID !== reactRootID); |
| |
| if (current === containersByReactRootID[reactRootID]) { |
| return node; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Temporary (?) hack so that we can store all top-level pending updates on |
| * composites instead of having to worry about different types of components |
| * here. |
| */ |
| var TopLevelWrapper = function () {}; |
| TopLevelWrapper.prototype.isReactComponent = {}; |
| if ("development" !== 'production') { |
| TopLevelWrapper.displayName = 'TopLevelWrapper'; |
| } |
| TopLevelWrapper.prototype.render = function () { |
| // this.props is actually a ReactElement |
| return this.props; |
| }; |
| |
| /** |
| * Mounting is the process of initializing a React component by creating its |
| * representative DOM elements and inserting them into a supplied `container`. |
| * Any prior content inside `container` is destroyed in the process. |
| * |
| * ReactMount.render( |
| * component, |
| * document.getElementById('container') |
| * ); |
| * |
| * <div id="container"> <-- Supplied `container`. |
| * <div data-reactid=".3"> <-- Rendered reactRoot of React |
| * // ... component. |
| * </div> |
| * </div> |
| * |
| * Inside of `container`, the first element rendered is the "reactRoot". |
| */ |
| var ReactMount = { |
| |
| TopLevelWrapper: TopLevelWrapper, |
| |
| /** Exposed for debugging purposes **/ |
| _instancesByReactRootID: instancesByReactRootID, |
| |
| /** |
| * This is a hook provided to support rendering React components while |
| * ensuring that the apparent scroll position of its `container` does not |
| * change. |
| * |
| * @param {DOMElement} container The `container` being rendered into. |
| * @param {function} renderCallback This must be called once to do the render. |
| */ |
| scrollMonitor: function (container, renderCallback) { |
| renderCallback(); |
| }, |
| |
| /** |
| * Take a component that's already mounted into the DOM and replace its props |
| * @param {ReactComponent} prevComponent component instance already in the DOM |
| * @param {ReactElement} nextElement component instance to render |
| * @param {DOMElement} container container to render into |
| * @param {?function} callback function triggered on completion |
| */ |
| _updateRootComponent: function (prevComponent, nextElement, container, callback) { |
| ReactMount.scrollMonitor(container, function () { |
| ReactUpdateQueue.enqueueElementInternal(prevComponent, nextElement); |
| if (callback) { |
| ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback); |
| } |
| }); |
| |
| if ("development" !== 'production') { |
| // Record the root element in case it later gets transplanted. |
| rootElementsByReactRootID[getReactRootID(container)] = getReactRootElementInContainer(container); |
| } |
| |
| return prevComponent; |
| }, |
| |
| /** |
| * Register a component into the instance map and starts scroll value |
| * monitoring |
| * @param {ReactComponent} nextComponent component instance to render |
| * @param {DOMElement} container container to render into |
| * @return {string} reactRoot ID prefix |
| */ |
| _registerComponent: function (nextComponent, container) { |
| !(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? "development" !== 'production' ? invariant(false, '_registerComponent(...): Target container is not a DOM element.') : invariant(false) : undefined; |
| |
| ReactBrowserEventEmitter.ensureScrollValueMonitoring(); |
| |
| var reactRootID = ReactMount.registerContainer(container); |
| instancesByReactRootID[reactRootID] = nextComponent; |
| return reactRootID; |
| }, |
| |
| /** |
| * Render a new component into the DOM. |
| * @param {ReactElement} nextElement element to render |
| * @param {DOMElement} container container to render into |
| * @param {boolean} shouldReuseMarkup if we should skip the markup insertion |
| * @return {ReactComponent} nextComponent |
| */ |
| _renderNewRootComponent: function (nextElement, container, shouldReuseMarkup, context) { |
| // Various parts of our code (such as ReactCompositeComponent's |
| // _renderValidatedComponent) assume that calls to render aren't nested; |
| // verify that that's the case. |
| "development" !== 'production' ? warning(ReactCurrentOwner.current == null, '_renderNewRootComponent(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from ' + 'render is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : undefined; |
| |
| var componentInstance = instantiateReactComponent(nextElement, null); |
| var reactRootID = ReactMount._registerComponent(componentInstance, container); |
| |
| // The initial render is synchronous but any updates that happen during |
| // rendering, in componentWillMount or componentDidMount, will be batched |
| // according to the current batching strategy. |
| |
| ReactUpdates.batchedUpdates(batchedMountComponentIntoNode, componentInstance, reactRootID, container, shouldReuseMarkup, context); |
| |
| if ("development" !== 'production') { |
| // Record the root element in case it later gets transplanted. |
| rootElementsByReactRootID[reactRootID] = getReactRootElementInContainer(container); |
| } |
| |
| return componentInstance; |
| }, |
| |
| /** |
| * Renders a React component into the DOM in the supplied `container`. |
| * |
| * If the React component was previously rendered into `container`, this will |
| * perform an update on it and only mutate the DOM as necessary to reflect the |
| * latest React component. |
| * |
| * @param {ReactComponent} parentComponent The conceptual parent of this render tree. |
| * @param {ReactElement} nextElement Component element to render. |
| * @param {DOMElement} container DOM element to render into. |
| * @param {?function} callback function triggered on completion |
| * @return {ReactComponent} Component instance rendered in `container`. |
| */ |
| renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) { |
| !(parentComponent != null && parentComponent._reactInternalInstance != null) ? "development" !== 'production' ? invariant(false, 'parentComponent must be a valid React Component') : invariant(false) : undefined; |
| return ReactMount._renderSubtreeIntoContainer(parentComponent, nextElement, container, callback); |
| }, |
| |
| _renderSubtreeIntoContainer: function (parentComponent, nextElement, container, callback) { |
| !ReactElement.isValidElement(nextElement) ? "development" !== 'production' ? invariant(false, 'ReactDOM.render(): Invalid component element.%s', typeof nextElement === 'string' ? ' Instead of passing an element string, make sure to instantiate ' + 'it by passing it to React.createElement.' : typeof nextElement === 'function' ? ' Instead of passing a component class, make sure to instantiate ' + 'it by passing it to React.createElement.' : |
| // Check if it quacks like an element |
| nextElement != null && nextElement.props !== undefined ? ' This may be caused by unintentionally loading two independent ' + 'copies of React.' : '') : invariant(false) : undefined; |
| |
| "development" !== 'production' ? warning(!container || !container.tagName || container.tagName.toUpperCase() !== 'BODY', 'render(): Rendering components directly into document.body is ' + 'discouraged, since its children are often manipulated by third-party ' + 'scripts and browser extensions. This may lead to subtle ' + 'reconciliation issues. Try rendering into a container element created ' + 'for your app.') : undefined; |
| |
| var nextWrappedElement = new ReactElement(TopLevelWrapper, null, null, null, null, null, nextElement); |
| |
| var prevComponent = instancesByReactRootID[getReactRootID(container)]; |
| |
| if (prevComponent) { |
| var prevWrappedElement = prevComponent._currentElement; |
| var prevElement = prevWrappedElement.props; |
| if (shouldUpdateReactComponent(prevElement, nextElement)) { |
| var publicInst = prevComponent._renderedComponent.getPublicInstance(); |
| var updatedCallback = callback && function () { |
| callback.call(publicInst); |
| }; |
| ReactMount._updateRootComponent(prevComponent, nextWrappedElement, container, updatedCallback); |
| return publicInst; |
| } else { |
| ReactMount.unmountComponentAtNode(container); |
| } |
| } |
| |
| var reactRootElement = getReactRootElementInContainer(container); |
| var containerHasReactMarkup = reactRootElement && !!internalGetID(reactRootElement); |
| var containerHasNonRootReactChild = hasNonRootReactChild(container); |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(!containerHasNonRootReactChild, 'render(...): Replacing React-rendered children with a new root ' + 'component. If you intended to update the children of this node, ' + 'you should instead have the existing children update their state ' + 'and render the new components instead of calling ReactDOM.render.') : undefined; |
| |
| if (!containerHasReactMarkup || reactRootElement.nextSibling) { |
| var rootElementSibling = reactRootElement; |
| while (rootElementSibling) { |
| if (internalGetID(rootElementSibling)) { |
| "development" !== 'production' ? warning(false, 'render(): Target node has markup rendered by React, but there ' + 'are unrelated nodes as well. This is most commonly caused by ' + 'white-space inserted around server-rendered markup.') : undefined; |
| break; |
| } |
| rootElementSibling = rootElementSibling.nextSibling; |
| } |
| } |
| } |
| |
| var shouldReuseMarkup = containerHasReactMarkup && !prevComponent && !containerHasNonRootReactChild; |
| var component = ReactMount._renderNewRootComponent(nextWrappedElement, container, shouldReuseMarkup, parentComponent != null ? parentComponent._reactInternalInstance._processChildContext(parentComponent._reactInternalInstance._context) : emptyObject)._renderedComponent.getPublicInstance(); |
| if (callback) { |
| callback.call(component); |
| } |
| return component; |
| }, |
| |
| /** |
| * Renders a React component into the DOM in the supplied `container`. |
| * |
| * If the React component was previously rendered into `container`, this will |
| * perform an update on it and only mutate the DOM as necessary to reflect the |
| * latest React component. |
| * |
| * @param {ReactElement} nextElement Component element to render. |
| * @param {DOMElement} container DOM element to render into. |
| * @param {?function} callback function triggered on completion |
| * @return {ReactComponent} Component instance rendered in `container`. |
| */ |
| render: function (nextElement, container, callback) { |
| return ReactMount._renderSubtreeIntoContainer(null, nextElement, container, callback); |
| }, |
| |
| /** |
| * Registers a container node into which React components will be rendered. |
| * This also creates the "reactRoot" ID that will be assigned to the element |
| * rendered within. |
| * |
| * @param {DOMElement} container DOM element to register as a container. |
| * @return {string} The "reactRoot" ID of elements rendered within. |
| */ |
| registerContainer: function (container) { |
| var reactRootID = getReactRootID(container); |
| if (reactRootID) { |
| // If one exists, make sure it is a valid "reactRoot" ID. |
| reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(reactRootID); |
| } |
| if (!reactRootID) { |
| // No valid "reactRoot" ID found, create one. |
| reactRootID = ReactInstanceHandles.createReactRootID(); |
| } |
| containersByReactRootID[reactRootID] = container; |
| return reactRootID; |
| }, |
| |
| /** |
| * Unmounts and destroys the React component rendered in the `container`. |
| * |
| * @param {DOMElement} container DOM element containing a React component. |
| * @return {boolean} True if a component was found in and unmounted from |
| * `container` |
| */ |
| unmountComponentAtNode: function (container) { |
| // Various parts of our code (such as ReactCompositeComponent's |
| // _renderValidatedComponent) assume that calls to render aren't nested; |
| // verify that that's the case. (Strictly speaking, unmounting won't cause a |
| // render but we still don't expect to be in a render call here.) |
| "development" !== 'production' ? warning(ReactCurrentOwner.current == null, 'unmountComponentAtNode(): Render methods should be a pure function ' + 'of props and state; triggering nested component updates from render ' + 'is not allowed. If necessary, trigger nested updates in ' + 'componentDidUpdate. Check the render method of %s.', ReactCurrentOwner.current && ReactCurrentOwner.current.getName() || 'ReactCompositeComponent') : undefined; |
| |
| !(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? "development" !== 'production' ? invariant(false, 'unmountComponentAtNode(...): Target container is not a DOM element.') : invariant(false) : undefined; |
| |
| var reactRootID = getReactRootID(container); |
| var component = instancesByReactRootID[reactRootID]; |
| if (!component) { |
| // Check if the node being unmounted was rendered by React, but isn't a |
| // root node. |
| var containerHasNonRootReactChild = hasNonRootReactChild(container); |
| |
| // Check if the container itself is a React root node. |
| var containerID = internalGetID(container); |
| var isContainerReactRoot = containerID && containerID === ReactInstanceHandles.getReactRootIDFromNodeID(containerID); |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(!containerHasNonRootReactChild, 'unmountComponentAtNode(): The node you\'re attempting to unmount ' + 'was rendered by React and is not a top-level container. %s', isContainerReactRoot ? 'You may have accidentally passed in a React root node instead ' + 'of its container.' : 'Instead, have the parent component update its state and ' + 'rerender in order to remove this component.') : undefined; |
| } |
| |
| return false; |
| } |
| ReactUpdates.batchedUpdates(unmountComponentFromNode, component, container); |
| delete instancesByReactRootID[reactRootID]; |
| delete containersByReactRootID[reactRootID]; |
| if ("development" !== 'production') { |
| delete rootElementsByReactRootID[reactRootID]; |
| } |
| return true; |
| }, |
| |
| /** |
| * Finds the container DOM element that contains React component to which the |
| * supplied DOM `id` belongs. |
| * |
| * @param {string} id The ID of an element rendered by a React component. |
| * @return {?DOMElement} DOM element that contains the `id`. |
| */ |
| findReactContainerForID: function (id) { |
| var reactRootID = ReactInstanceHandles.getReactRootIDFromNodeID(id); |
| var container = containersByReactRootID[reactRootID]; |
| |
| if ("development" !== 'production') { |
| var rootElement = rootElementsByReactRootID[reactRootID]; |
| if (rootElement && rootElement.parentNode !== container) { |
| "development" !== 'production' ? warning( |
| // Call internalGetID here because getID calls isValid which calls |
| // findReactContainerForID (this function). |
| internalGetID(rootElement) === reactRootID, 'ReactMount: Root element ID differed from reactRootID.') : undefined; |
| var containerChild = container.firstChild; |
| if (containerChild && reactRootID === internalGetID(containerChild)) { |
| // If the container has a new child with the same ID as the old |
| // root element, then rootElementsByReactRootID[reactRootID] is |
| // just stale and needs to be updated. The case that deserves a |
| // warning is when the container is empty. |
| rootElementsByReactRootID[reactRootID] = containerChild; |
| } else { |
| "development" !== 'production' ? warning(false, 'ReactMount: Root element has been removed from its original ' + 'container. New container: %s', rootElement.parentNode) : undefined; |
| } |
| } |
| } |
| |
| return container; |
| }, |
| |
| /** |
| * Finds an element rendered by React with the supplied ID. |
| * |
| * @param {string} id ID of a DOM node in the React component. |
| * @return {DOMElement} Root DOM node of the React component. |
| */ |
| findReactNodeByID: function (id) { |
| var reactRoot = ReactMount.findReactContainerForID(id); |
| return ReactMount.findComponentRoot(reactRoot, id); |
| }, |
| |
| /** |
| * Traverses up the ancestors of the supplied node to find a node that is a |
| * DOM representation of a React component rendered by this copy of React. |
| * |
| * @param {*} node |
| * @return {?DOMEventTarget} |
| * @internal |
| */ |
| getFirstReactDOM: function (node) { |
| return findFirstReactDOMImpl(node); |
| }, |
| |
| /** |
| * Finds a node with the supplied `targetID` inside of the supplied |
| * `ancestorNode`. Exploits the ID naming scheme to perform the search |
| * quickly. |
| * |
| * @param {DOMEventTarget} ancestorNode Search from this root. |
| * @pararm {string} targetID ID of the DOM representation of the component. |
| * @return {DOMEventTarget} DOM node with the supplied `targetID`. |
| * @internal |
| */ |
| findComponentRoot: function (ancestorNode, targetID) { |
| var firstChildren = findComponentRootReusableArray; |
| var childIndex = 0; |
| |
| var deepestAncestor = findDeepestCachedAncestor(targetID) || ancestorNode; |
| |
| if ("development" !== 'production') { |
| // This will throw on the next line; give an early warning |
| "development" !== 'production' ? warning(deepestAncestor != null, 'React can\'t find the root component node for data-reactid value ' + '`%s`. If you\'re seeing this message, it probably means that ' + 'you\'ve loaded two copies of React on the page. At this time, only ' + 'a single copy of React can be loaded at a time.', targetID) : undefined; |
| } |
| |
| firstChildren[0] = deepestAncestor.firstChild; |
| firstChildren.length = 1; |
| |
| while (childIndex < firstChildren.length) { |
| var child = firstChildren[childIndex++]; |
| var targetChild; |
| |
| while (child) { |
| var childID = ReactMount.getID(child); |
| if (childID) { |
| // Even if we find the node we're looking for, we finish looping |
| // through its siblings to ensure they're cached so that we don't have |
| // to revisit this node again. Otherwise, we make n^2 calls to getID |
| // when visiting the many children of a single node in order. |
| |
| if (targetID === childID) { |
| targetChild = child; |
| } else if (ReactInstanceHandles.isAncestorIDOf(childID, targetID)) { |
| // If we find a child whose ID is an ancestor of the given ID, |
| // then we can be sure that we only want to search the subtree |
| // rooted at this child, so we can throw out the rest of the |
| // search state. |
| firstChildren.length = childIndex = 0; |
| firstChildren.push(child.firstChild); |
| } |
| } else { |
| // If this child had no ID, then there's a chance that it was |
| // injected automatically by the browser, as when a `<table>` |
| // element sprouts an extra `<tbody>` child as a side effect of |
| // `.innerHTML` parsing. Optimistically continue down this |
| // branch, but not before examining the other siblings. |
| firstChildren.push(child.firstChild); |
| } |
| |
| child = child.nextSibling; |
| } |
| |
| if (targetChild) { |
| // Emptying firstChildren/findComponentRootReusableArray is |
| // not necessary for correctness, but it helps the GC reclaim |
| // any nodes that were left at the end of the search. |
| firstChildren.length = 0; |
| |
| return targetChild; |
| } |
| } |
| |
| firstChildren.length = 0; |
| |
| !false ? "development" !== 'production' ? invariant(false, 'findComponentRoot(..., %s): Unable to find element. This probably ' + 'means the DOM was unexpectedly mutated (e.g., by the browser), ' + 'usually due to forgetting a <tbody> when using tables, nesting tags ' + 'like <form>, <p>, or <a>, or using non-SVG elements in an <svg> ' + 'parent. ' + 'Try inspecting the child nodes of the element with React ID `%s`.', targetID, ReactMount.getID(ancestorNode)) : invariant(false) : undefined; |
| }, |
| |
| _mountImageIntoNode: function (markup, container, shouldReuseMarkup, transaction) { |
| !(container && (container.nodeType === ELEMENT_NODE_TYPE || container.nodeType === DOC_NODE_TYPE || container.nodeType === DOCUMENT_FRAGMENT_NODE_TYPE)) ? "development" !== 'production' ? invariant(false, 'mountComponentIntoNode(...): Target container is not valid.') : invariant(false) : undefined; |
| |
| if (shouldReuseMarkup) { |
| var rootElement = getReactRootElementInContainer(container); |
| if (ReactMarkupChecksum.canReuseMarkup(markup, rootElement)) { |
| return; |
| } else { |
| var checksum = rootElement.getAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME); |
| rootElement.removeAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME); |
| |
| var rootMarkup = rootElement.outerHTML; |
| rootElement.setAttribute(ReactMarkupChecksum.CHECKSUM_ATTR_NAME, checksum); |
| |
| var normalizedMarkup = markup; |
| if ("development" !== 'production') { |
| // because rootMarkup is retrieved from the DOM, various normalizations |
| // will have occurred which will not be present in `markup`. Here, |
| // insert markup into a <div> or <iframe> depending on the container |
| // type to perform the same normalizations before comparing. |
| var normalizer; |
| if (container.nodeType === ELEMENT_NODE_TYPE) { |
| normalizer = document.createElement('div'); |
| normalizer.innerHTML = markup; |
| normalizedMarkup = normalizer.innerHTML; |
| } else { |
| normalizer = document.createElement('iframe'); |
| document.body.appendChild(normalizer); |
| normalizer.contentDocument.write(markup); |
| normalizedMarkup = normalizer.contentDocument.documentElement.outerHTML; |
| document.body.removeChild(normalizer); |
| } |
| } |
| |
| var diffIndex = firstDifferenceIndex(normalizedMarkup, rootMarkup); |
| var difference = ' (client) ' + normalizedMarkup.substring(diffIndex - 20, diffIndex + 20) + '\n (server) ' + rootMarkup.substring(diffIndex - 20, diffIndex + 20); |
| |
| !(container.nodeType !== DOC_NODE_TYPE) ? "development" !== 'production' ? invariant(false, 'You\'re trying to render a component to the document using ' + 'server rendering but the checksum was invalid. This usually ' + 'means you rendered a different component type or props on ' + 'the client from the one on the server, or your render() ' + 'methods are impure. React cannot handle this case due to ' + 'cross-browser quirks by rendering at the document root. You ' + 'should look for environment dependent code in your components ' + 'and ensure the props are the same client and server side:\n%s', difference) : invariant(false) : undefined; |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, 'React attempted to reuse markup in a container but the ' + 'checksum was invalid. This generally means that you are ' + 'using server rendering and the markup generated on the ' + 'server was not what the client was expecting. React injected ' + 'new markup to compensate which works but you have lost many ' + 'of the benefits of server rendering. Instead, figure out ' + 'why the markup being generated is different on the client ' + 'or server:\n%s', difference) : undefined; |
| } |
| } |
| } |
| |
| !(container.nodeType !== DOC_NODE_TYPE) ? "development" !== 'production' ? invariant(false, 'You\'re trying to render a component to the document but ' + 'you didn\'t use server rendering. We can\'t do this ' + 'without using server rendering due to cross-browser quirks. ' + 'See ReactDOMServer.renderToString() for server rendering.') : invariant(false) : undefined; |
| |
| if (transaction.useCreateElement) { |
| while (container.lastChild) { |
| container.removeChild(container.lastChild); |
| } |
| container.appendChild(markup); |
| } else { |
| setInnerHTML(container, markup); |
| } |
| }, |
| |
| ownerDocumentContextKey: ownerDocumentContextKey, |
| |
| /** |
| * React ID utilities. |
| */ |
| |
| getReactRootID: getReactRootID, |
| |
| getID: getID, |
| |
| setID: setID, |
| |
| getNode: getNode, |
| |
| getNodeFromInstance: getNodeFromInstance, |
| |
| isValid: isValid, |
| |
| purgeID: purgeID |
| }; |
| |
| ReactPerf.measureMethods(ReactMount, 'ReactMount', { |
| _renderNewRootComponent: '_renderNewRootComponent', |
| _mountImageIntoNode: '_mountImageIntoNode' |
| }); |
| |
| module.exports = ReactMount; |
| },{"10":10,"132":132,"138":138,"141":141,"144":144,"150":150,"154":154,"161":161,"173":173,"24":24,"28":28,"39":39,"44":44,"57":57,"60":60,"67":67,"68":68,"71":71,"78":78,"84":84,"95":95,"96":96}],73:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactMultiChild |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactComponentEnvironment = _dereq_(36); |
| var ReactMultiChildUpdateTypes = _dereq_(74); |
| |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactReconciler = _dereq_(84); |
| var ReactChildReconciler = _dereq_(31); |
| |
| var flattenChildren = _dereq_(123); |
| |
| /** |
| * Updating children of a component may trigger recursive updates. The depth is |
| * used to batch recursive updates to render markup more efficiently. |
| * |
| * @type {number} |
| * @private |
| */ |
| var updateDepth = 0; |
| |
| /** |
| * Queue of update configuration objects. |
| * |
| * Each object has a `type` property that is in `ReactMultiChildUpdateTypes`. |
| * |
| * @type {array<object>} |
| * @private |
| */ |
| var updateQueue = []; |
| |
| /** |
| * Queue of markup to be rendered. |
| * |
| * @type {array<string>} |
| * @private |
| */ |
| var markupQueue = []; |
| |
| /** |
| * Enqueues markup to be rendered and inserted at a supplied index. |
| * |
| * @param {string} parentID ID of the parent component. |
| * @param {string} markup Markup that renders into an element. |
| * @param {number} toIndex Destination index. |
| * @private |
| */ |
| function enqueueInsertMarkup(parentID, markup, toIndex) { |
| // NOTE: Null values reduce hidden classes. |
| updateQueue.push({ |
| parentID: parentID, |
| parentNode: null, |
| type: ReactMultiChildUpdateTypes.INSERT_MARKUP, |
| markupIndex: markupQueue.push(markup) - 1, |
| content: null, |
| fromIndex: null, |
| toIndex: toIndex |
| }); |
| } |
| |
| /** |
| * Enqueues moving an existing element to another index. |
| * |
| * @param {string} parentID ID of the parent component. |
| * @param {number} fromIndex Source index of the existing element. |
| * @param {number} toIndex Destination index of the element. |
| * @private |
| */ |
| function enqueueMove(parentID, fromIndex, toIndex) { |
| // NOTE: Null values reduce hidden classes. |
| updateQueue.push({ |
| parentID: parentID, |
| parentNode: null, |
| type: ReactMultiChildUpdateTypes.MOVE_EXISTING, |
| markupIndex: null, |
| content: null, |
| fromIndex: fromIndex, |
| toIndex: toIndex |
| }); |
| } |
| |
| /** |
| * Enqueues removing an element at an index. |
| * |
| * @param {string} parentID ID of the parent component. |
| * @param {number} fromIndex Index of the element to remove. |
| * @private |
| */ |
| function enqueueRemove(parentID, fromIndex) { |
| // NOTE: Null values reduce hidden classes. |
| updateQueue.push({ |
| parentID: parentID, |
| parentNode: null, |
| type: ReactMultiChildUpdateTypes.REMOVE_NODE, |
| markupIndex: null, |
| content: null, |
| fromIndex: fromIndex, |
| toIndex: null |
| }); |
| } |
| |
| /** |
| * Enqueues setting the markup of a node. |
| * |
| * @param {string} parentID ID of the parent component. |
| * @param {string} markup Markup that renders into an element. |
| * @private |
| */ |
| function enqueueSetMarkup(parentID, markup) { |
| // NOTE: Null values reduce hidden classes. |
| updateQueue.push({ |
| parentID: parentID, |
| parentNode: null, |
| type: ReactMultiChildUpdateTypes.SET_MARKUP, |
| markupIndex: null, |
| content: markup, |
| fromIndex: null, |
| toIndex: null |
| }); |
| } |
| |
| /** |
| * Enqueues setting the text content. |
| * |
| * @param {string} parentID ID of the parent component. |
| * @param {string} textContent Text content to set. |
| * @private |
| */ |
| function enqueueTextContent(parentID, textContent) { |
| // NOTE: Null values reduce hidden classes. |
| updateQueue.push({ |
| parentID: parentID, |
| parentNode: null, |
| type: ReactMultiChildUpdateTypes.TEXT_CONTENT, |
| markupIndex: null, |
| content: textContent, |
| fromIndex: null, |
| toIndex: null |
| }); |
| } |
| |
| /** |
| * Processes any enqueued updates. |
| * |
| * @private |
| */ |
| function processQueue() { |
| if (updateQueue.length) { |
| ReactComponentEnvironment.processChildrenUpdates(updateQueue, markupQueue); |
| clearQueue(); |
| } |
| } |
| |
| /** |
| * Clears any enqueued updates. |
| * |
| * @private |
| */ |
| function clearQueue() { |
| updateQueue.length = 0; |
| markupQueue.length = 0; |
| } |
| |
| /** |
| * ReactMultiChild are capable of reconciling multiple children. |
| * |
| * @class ReactMultiChild |
| * @internal |
| */ |
| var ReactMultiChild = { |
| |
| /** |
| * Provides common functionality for components that must reconcile multiple |
| * children. This is used by `ReactDOMComponent` to mount, update, and |
| * unmount child components. |
| * |
| * @lends {ReactMultiChild.prototype} |
| */ |
| Mixin: { |
| |
| _reconcilerInstantiateChildren: function (nestedChildren, transaction, context) { |
| if ("development" !== 'production') { |
| if (this._currentElement) { |
| try { |
| ReactCurrentOwner.current = this._currentElement._owner; |
| return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context); |
| } finally { |
| ReactCurrentOwner.current = null; |
| } |
| } |
| } |
| return ReactChildReconciler.instantiateChildren(nestedChildren, transaction, context); |
| }, |
| |
| _reconcilerUpdateChildren: function (prevChildren, nextNestedChildrenElements, transaction, context) { |
| var nextChildren; |
| if ("development" !== 'production') { |
| if (this._currentElement) { |
| try { |
| ReactCurrentOwner.current = this._currentElement._owner; |
| nextChildren = flattenChildren(nextNestedChildrenElements); |
| } finally { |
| ReactCurrentOwner.current = null; |
| } |
| return ReactChildReconciler.updateChildren(prevChildren, nextChildren, transaction, context); |
| } |
| } |
| nextChildren = flattenChildren(nextNestedChildrenElements); |
| return ReactChildReconciler.updateChildren(prevChildren, nextChildren, transaction, context); |
| }, |
| |
| /** |
| * Generates a "mount image" for each of the supplied children. In the case |
| * of `ReactDOMComponent`, a mount image is a string of markup. |
| * |
| * @param {?object} nestedChildren Nested child maps. |
| * @return {array} An array of mounted representations. |
| * @internal |
| */ |
| mountChildren: function (nestedChildren, transaction, context) { |
| var children = this._reconcilerInstantiateChildren(nestedChildren, transaction, context); |
| this._renderedChildren = children; |
| var mountImages = []; |
| var index = 0; |
| for (var name in children) { |
| if (children.hasOwnProperty(name)) { |
| var child = children[name]; |
| // Inlined for performance, see `ReactInstanceHandles.createReactID`. |
| var rootID = this._rootNodeID + name; |
| var mountImage = ReactReconciler.mountComponent(child, rootID, transaction, context); |
| child._mountIndex = index++; |
| mountImages.push(mountImage); |
| } |
| } |
| return mountImages; |
| }, |
| |
| /** |
| * Replaces any rendered children with a text content string. |
| * |
| * @param {string} nextContent String of content. |
| * @internal |
| */ |
| updateTextContent: function (nextContent) { |
| updateDepth++; |
| var errorThrown = true; |
| try { |
| var prevChildren = this._renderedChildren; |
| // Remove any rendered children. |
| ReactChildReconciler.unmountChildren(prevChildren); |
| // TODO: The setTextContent operation should be enough |
| for (var name in prevChildren) { |
| if (prevChildren.hasOwnProperty(name)) { |
| this._unmountChild(prevChildren[name]); |
| } |
| } |
| // Set new text content. |
| this.setTextContent(nextContent); |
| errorThrown = false; |
| } finally { |
| updateDepth--; |
| if (!updateDepth) { |
| if (errorThrown) { |
| clearQueue(); |
| } else { |
| processQueue(); |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Replaces any rendered children with a markup string. |
| * |
| * @param {string} nextMarkup String of markup. |
| * @internal |
| */ |
| updateMarkup: function (nextMarkup) { |
| updateDepth++; |
| var errorThrown = true; |
| try { |
| var prevChildren = this._renderedChildren; |
| // Remove any rendered children. |
| ReactChildReconciler.unmountChildren(prevChildren); |
| for (var name in prevChildren) { |
| if (prevChildren.hasOwnProperty(name)) { |
| this._unmountChildByName(prevChildren[name], name); |
| } |
| } |
| this.setMarkup(nextMarkup); |
| errorThrown = false; |
| } finally { |
| updateDepth--; |
| if (!updateDepth) { |
| if (errorThrown) { |
| clearQueue(); |
| } else { |
| processQueue(); |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Updates the rendered children with new children. |
| * |
| * @param {?object} nextNestedChildrenElements Nested child element maps. |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| */ |
| updateChildren: function (nextNestedChildrenElements, transaction, context) { |
| updateDepth++; |
| var errorThrown = true; |
| try { |
| this._updateChildren(nextNestedChildrenElements, transaction, context); |
| errorThrown = false; |
| } finally { |
| updateDepth--; |
| if (!updateDepth) { |
| if (errorThrown) { |
| clearQueue(); |
| } else { |
| processQueue(); |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Improve performance by isolating this hot code path from the try/catch |
| * block in `updateChildren`. |
| * |
| * @param {?object} nextNestedChildrenElements Nested child element maps. |
| * @param {ReactReconcileTransaction} transaction |
| * @final |
| * @protected |
| */ |
| _updateChildren: function (nextNestedChildrenElements, transaction, context) { |
| var prevChildren = this._renderedChildren; |
| var nextChildren = this._reconcilerUpdateChildren(prevChildren, nextNestedChildrenElements, transaction, context); |
| this._renderedChildren = nextChildren; |
| if (!nextChildren && !prevChildren) { |
| return; |
| } |
| var name; |
| // `nextIndex` will increment for each child in `nextChildren`, but |
| // `lastIndex` will be the last index visited in `prevChildren`. |
| var lastIndex = 0; |
| var nextIndex = 0; |
| for (name in nextChildren) { |
| if (!nextChildren.hasOwnProperty(name)) { |
| continue; |
| } |
| var prevChild = prevChildren && prevChildren[name]; |
| var nextChild = nextChildren[name]; |
| if (prevChild === nextChild) { |
| this.moveChild(prevChild, nextIndex, lastIndex); |
| lastIndex = Math.max(prevChild._mountIndex, lastIndex); |
| prevChild._mountIndex = nextIndex; |
| } else { |
| if (prevChild) { |
| // Update `lastIndex` before `_mountIndex` gets unset by unmounting. |
| lastIndex = Math.max(prevChild._mountIndex, lastIndex); |
| this._unmountChild(prevChild); |
| } |
| // The child must be instantiated before it's mounted. |
| this._mountChildByNameAtIndex(nextChild, name, nextIndex, transaction, context); |
| } |
| nextIndex++; |
| } |
| // Remove children that are no longer present. |
| for (name in prevChildren) { |
| if (prevChildren.hasOwnProperty(name) && !(nextChildren && nextChildren.hasOwnProperty(name))) { |
| this._unmountChild(prevChildren[name]); |
| } |
| } |
| }, |
| |
| /** |
| * Unmounts all rendered children. This should be used to clean up children |
| * when this component is unmounted. |
| * |
| * @internal |
| */ |
| unmountChildren: function () { |
| var renderedChildren = this._renderedChildren; |
| ReactChildReconciler.unmountChildren(renderedChildren); |
| this._renderedChildren = null; |
| }, |
| |
| /** |
| * Moves a child component to the supplied index. |
| * |
| * @param {ReactComponent} child Component to move. |
| * @param {number} toIndex Destination index of the element. |
| * @param {number} lastIndex Last index visited of the siblings of `child`. |
| * @protected |
| */ |
| moveChild: function (child, toIndex, lastIndex) { |
| // If the index of `child` is less than `lastIndex`, then it needs to |
| // be moved. Otherwise, we do not need to move it because a child will be |
| // inserted or moved before `child`. |
| if (child._mountIndex < lastIndex) { |
| enqueueMove(this._rootNodeID, child._mountIndex, toIndex); |
| } |
| }, |
| |
| /** |
| * Creates a child component. |
| * |
| * @param {ReactComponent} child Component to create. |
| * @param {string} mountImage Markup to insert. |
| * @protected |
| */ |
| createChild: function (child, mountImage) { |
| enqueueInsertMarkup(this._rootNodeID, mountImage, child._mountIndex); |
| }, |
| |
| /** |
| * Removes a child component. |
| * |
| * @param {ReactComponent} child Child to remove. |
| * @protected |
| */ |
| removeChild: function (child) { |
| enqueueRemove(this._rootNodeID, child._mountIndex); |
| }, |
| |
| /** |
| * Sets this text content string. |
| * |
| * @param {string} textContent Text content to set. |
| * @protected |
| */ |
| setTextContent: function (textContent) { |
| enqueueTextContent(this._rootNodeID, textContent); |
| }, |
| |
| /** |
| * Sets this markup string. |
| * |
| * @param {string} markup Markup to set. |
| * @protected |
| */ |
| setMarkup: function (markup) { |
| enqueueSetMarkup(this._rootNodeID, markup); |
| }, |
| |
| /** |
| * Mounts a child with the supplied name. |
| * |
| * NOTE: This is part of `updateChildren` and is here for readability. |
| * |
| * @param {ReactComponent} child Component to mount. |
| * @param {string} name Name of the child. |
| * @param {number} index Index at which to insert the child. |
| * @param {ReactReconcileTransaction} transaction |
| * @private |
| */ |
| _mountChildByNameAtIndex: function (child, name, index, transaction, context) { |
| // Inlined for performance, see `ReactInstanceHandles.createReactID`. |
| var rootID = this._rootNodeID + name; |
| var mountImage = ReactReconciler.mountComponent(child, rootID, transaction, context); |
| child._mountIndex = index; |
| this.createChild(child, mountImage); |
| }, |
| |
| /** |
| * Unmounts a rendered child. |
| * |
| * NOTE: This is part of `updateChildren` and is here for readability. |
| * |
| * @param {ReactComponent} child Component to unmount. |
| * @private |
| */ |
| _unmountChild: function (child) { |
| this.removeChild(child); |
| child._mountIndex = null; |
| } |
| |
| } |
| |
| }; |
| |
| module.exports = ReactMultiChild; |
| },{"123":123,"31":31,"36":36,"39":39,"74":74,"84":84}],74:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactMultiChildUpdateTypes |
| */ |
| |
| 'use strict'; |
| |
| var keyMirror = _dereq_(165); |
| |
| /** |
| * When a component's children are updated, a series of update configuration |
| * objects are created in order to batch and serialize the required changes. |
| * |
| * Enumerates all the possible types of update configurations. |
| * |
| * @internal |
| */ |
| var ReactMultiChildUpdateTypes = keyMirror({ |
| INSERT_MARKUP: null, |
| MOVE_EXISTING: null, |
| REMOVE_NODE: null, |
| SET_MARKUP: null, |
| TEXT_CONTENT: null |
| }); |
| |
| module.exports = ReactMultiChildUpdateTypes; |
| },{"165":165}],75:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactNativeComponent |
| */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| |
| var autoGenerateWrapperClass = null; |
| var genericComponentClass = null; |
| // This registry keeps track of wrapper classes around native tags. |
| var tagToComponentClass = {}; |
| var textComponentClass = null; |
| |
| var ReactNativeComponentInjection = { |
| // This accepts a class that receives the tag string. This is a catch all |
| // that can render any kind of tag. |
| injectGenericComponentClass: function (componentClass) { |
| genericComponentClass = componentClass; |
| }, |
| // This accepts a text component class that takes the text string to be |
| // rendered as props. |
| injectTextComponentClass: function (componentClass) { |
| textComponentClass = componentClass; |
| }, |
| // This accepts a keyed object with classes as values. Each key represents a |
| // tag. That particular tag will use this class instead of the generic one. |
| injectComponentClasses: function (componentClasses) { |
| assign(tagToComponentClass, componentClasses); |
| } |
| }; |
| |
| /** |
| * Get a composite component wrapper class for a specific tag. |
| * |
| * @param {ReactElement} element The tag for which to get the class. |
| * @return {function} The React class constructor function. |
| */ |
| function getComponentClassForElement(element) { |
| if (typeof element.type === 'function') { |
| return element.type; |
| } |
| var tag = element.type; |
| var componentClass = tagToComponentClass[tag]; |
| if (componentClass == null) { |
| tagToComponentClass[tag] = componentClass = autoGenerateWrapperClass(tag); |
| } |
| return componentClass; |
| } |
| |
| /** |
| * Get a native internal component class for a specific tag. |
| * |
| * @param {ReactElement} element The element to create. |
| * @return {function} The internal class constructor function. |
| */ |
| function createInternalComponent(element) { |
| !genericComponentClass ? "development" !== 'production' ? invariant(false, 'There is no registered component for the tag %s', element.type) : invariant(false) : undefined; |
| return new genericComponentClass(element.type, element.props); |
| } |
| |
| /** |
| * @param {ReactText} text |
| * @return {ReactComponent} |
| */ |
| function createInstanceForText(text) { |
| return new textComponentClass(text); |
| } |
| |
| /** |
| * @param {ReactComponent} component |
| * @return {boolean} |
| */ |
| function isTextComponent(component) { |
| return component instanceof textComponentClass; |
| } |
| |
| var ReactNativeComponent = { |
| getComponentClassForElement: getComponentClassForElement, |
| createInternalComponent: createInternalComponent, |
| createInstanceForText: createInstanceForText, |
| isTextComponent: isTextComponent, |
| injection: ReactNativeComponentInjection |
| }; |
| |
| module.exports = ReactNativeComponent; |
| },{"161":161,"24":24}],76:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactNoopUpdateQueue |
| */ |
| |
| 'use strict'; |
| |
| var warning = _dereq_(173); |
| |
| function warnTDZ(publicInstance, callerName) { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(false, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, publicInstance.constructor && publicInstance.constructor.displayName || '') : undefined; |
| } |
| } |
| |
| /** |
| * This is the abstract API for an update queue. |
| */ |
| var ReactNoopUpdateQueue = { |
| |
| /** |
| * Checks whether or not this composite component is mounted. |
| * @param {ReactClass} publicInstance The instance we want to test. |
| * @return {boolean} True if mounted, false otherwise. |
| * @protected |
| * @final |
| */ |
| isMounted: function (publicInstance) { |
| return false; |
| }, |
| |
| /** |
| * Enqueue a callback that will be executed after all the pending updates |
| * have processed. |
| * |
| * @param {ReactClass} publicInstance The instance to use as `this` context. |
| * @param {?function} callback Called after state is updated. |
| * @internal |
| */ |
| enqueueCallback: function (publicInstance, callback) {}, |
| |
| /** |
| * Forces an update. This should only be invoked when it is known with |
| * certainty that we are **not** in a DOM transaction. |
| * |
| * You may want to call this when you know that some deeper aspect of the |
| * component's state has changed but `setState` was not called. |
| * |
| * This will not invoke `shouldComponentUpdate`, but it will invoke |
| * `componentWillUpdate` and `componentDidUpdate`. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @internal |
| */ |
| enqueueForceUpdate: function (publicInstance) { |
| warnTDZ(publicInstance, 'forceUpdate'); |
| }, |
| |
| /** |
| * Replaces all of the state. Always use this or `setState` to mutate state. |
| * You should treat `this.state` as immutable. |
| * |
| * There is no guarantee that `this.state` will be immediately updated, so |
| * accessing `this.state` after calling this method may return the old value. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} completeState Next state. |
| * @internal |
| */ |
| enqueueReplaceState: function (publicInstance, completeState) { |
| warnTDZ(publicInstance, 'replaceState'); |
| }, |
| |
| /** |
| * Sets a subset of the state. This only exists because _pendingState is |
| * internal. This provides a merging strategy that is not available to deep |
| * properties which is confusing. TODO: Expose pendingState or don't use it |
| * during the merge. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} partialState Next partial state to be merged with state. |
| * @internal |
| */ |
| enqueueSetState: function (publicInstance, partialState) { |
| warnTDZ(publicInstance, 'setState'); |
| }, |
| |
| /** |
| * Sets a subset of the props. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} partialProps Subset of the next props. |
| * @internal |
| */ |
| enqueueSetProps: function (publicInstance, partialProps) { |
| warnTDZ(publicInstance, 'setProps'); |
| }, |
| |
| /** |
| * Replaces all of the props. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} props New props. |
| * @internal |
| */ |
| enqueueReplaceProps: function (publicInstance, props) { |
| warnTDZ(publicInstance, 'replaceProps'); |
| } |
| |
| }; |
| |
| module.exports = ReactNoopUpdateQueue; |
| },{"173":173}],77:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactOwner |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * ReactOwners are capable of storing references to owned components. |
| * |
| * All components are capable of //being// referenced by owner components, but |
| * only ReactOwner components are capable of //referencing// owned components. |
| * The named reference is known as a "ref". |
| * |
| * Refs are available when mounted and updated during reconciliation. |
| * |
| * var MyComponent = React.createClass({ |
| * render: function() { |
| * return ( |
| * <div onClick={this.handleClick}> |
| * <CustomComponent ref="custom" /> |
| * </div> |
| * ); |
| * }, |
| * handleClick: function() { |
| * this.refs.custom.handleClick(); |
| * }, |
| * componentDidMount: function() { |
| * this.refs.custom.initialize(); |
| * } |
| * }); |
| * |
| * Refs should rarely be used. When refs are used, they should only be done to |
| * control data that is not handled by React's data flow. |
| * |
| * @class ReactOwner |
| */ |
| var ReactOwner = { |
| |
| /** |
| * @param {?object} object |
| * @return {boolean} True if `object` is a valid owner. |
| * @final |
| */ |
| isValidOwner: function (object) { |
| return !!(object && typeof object.attachRef === 'function' && typeof object.detachRef === 'function'); |
| }, |
| |
| /** |
| * Adds a component by ref to an owner component. |
| * |
| * @param {ReactComponent} component Component to reference. |
| * @param {string} ref Name by which to refer to the component. |
| * @param {ReactOwner} owner Component on which to record the ref. |
| * @final |
| * @internal |
| */ |
| addComponentAsRefTo: function (component, ref, owner) { |
| !ReactOwner.isValidOwner(owner) ? "development" !== 'production' ? invariant(false, 'addComponentAsRefTo(...): Only a ReactOwner can have refs. You might ' + 'be adding a ref to a component that was not created inside a component\'s ' + '`render` method, or you have multiple copies of React loaded ' + '(details: https://fb.me/react-refs-must-have-owner).') : invariant(false) : undefined; |
| owner.attachRef(ref, component); |
| }, |
| |
| /** |
| * Removes a component by ref from an owner component. |
| * |
| * @param {ReactComponent} component Component to dereference. |
| * @param {string} ref Name of the ref to remove. |
| * @param {ReactOwner} owner Component on which the ref is recorded. |
| * @final |
| * @internal |
| */ |
| removeComponentAsRefFrom: function (component, ref, owner) { |
| !ReactOwner.isValidOwner(owner) ? "development" !== 'production' ? invariant(false, 'removeComponentAsRefFrom(...): Only a ReactOwner can have refs. You might ' + 'be removing a ref to a component that was not created inside a component\'s ' + '`render` method, or you have multiple copies of React loaded ' + '(details: https://fb.me/react-refs-must-have-owner).') : invariant(false) : undefined; |
| // Check that `component` is still the current ref because we do not want to |
| // detach the ref if another component stole it. |
| if (owner.getPublicInstance().refs[ref] === component.getPublicInstance()) { |
| owner.detachRef(ref); |
| } |
| } |
| |
| }; |
| |
| module.exports = ReactOwner; |
| },{"161":161}],78:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactPerf |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * ReactPerf is a general AOP system designed to measure performance. This |
| * module only has the hooks: see ReactDefaultPerf for the analysis tool. |
| */ |
| var ReactPerf = { |
| /** |
| * Boolean to enable/disable measurement. Set to false by default to prevent |
| * accidental logging and perf loss. |
| */ |
| enableMeasure: false, |
| |
| /** |
| * Holds onto the measure function in use. By default, don't measure |
| * anything, but we'll override this if we inject a measure function. |
| */ |
| storedMeasure: _noMeasure, |
| |
| /** |
| * @param {object} object |
| * @param {string} objectName |
| * @param {object<string>} methodNames |
| */ |
| measureMethods: function (object, objectName, methodNames) { |
| if ("development" !== 'production') { |
| for (var key in methodNames) { |
| if (!methodNames.hasOwnProperty(key)) { |
| continue; |
| } |
| object[key] = ReactPerf.measure(objectName, methodNames[key], object[key]); |
| } |
| } |
| }, |
| |
| /** |
| * Use this to wrap methods you want to measure. Zero overhead in production. |
| * |
| * @param {string} objName |
| * @param {string} fnName |
| * @param {function} func |
| * @return {function} |
| */ |
| measure: function (objName, fnName, func) { |
| if ("development" !== 'production') { |
| var measuredFunc = null; |
| var wrapper = function () { |
| if (ReactPerf.enableMeasure) { |
| if (!measuredFunc) { |
| measuredFunc = ReactPerf.storedMeasure(objName, fnName, func); |
| } |
| return measuredFunc.apply(this, arguments); |
| } |
| return func.apply(this, arguments); |
| }; |
| wrapper.displayName = objName + '_' + fnName; |
| return wrapper; |
| } |
| return func; |
| }, |
| |
| injection: { |
| /** |
| * @param {function} measure |
| */ |
| injectMeasure: function (measure) { |
| ReactPerf.storedMeasure = measure; |
| } |
| } |
| }; |
| |
| /** |
| * Simply passes through the measured function, without measuring it. |
| * |
| * @param {string} objName |
| * @param {string} fnName |
| * @param {function} func |
| * @return {function} |
| */ |
| function _noMeasure(objName, fnName, func) { |
| return func; |
| } |
| |
| module.exports = ReactPerf; |
| },{}],79:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactPropTransferer |
| */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| var joinClasses = _dereq_(164); |
| |
| /** |
| * Creates a transfer strategy that will merge prop values using the supplied |
| * `mergeStrategy`. If a prop was previously unset, this just sets it. |
| * |
| * @param {function} mergeStrategy |
| * @return {function} |
| */ |
| function createTransferStrategy(mergeStrategy) { |
| return function (props, key, value) { |
| if (!props.hasOwnProperty(key)) { |
| props[key] = value; |
| } else { |
| props[key] = mergeStrategy(props[key], value); |
| } |
| }; |
| } |
| |
| var transferStrategyMerge = createTransferStrategy(function (a, b) { |
| // `merge` overrides the first object's (`props[key]` above) keys using the |
| // second object's (`value`) keys. An object's style's existing `propA` would |
| // get overridden. Flip the order here. |
| return assign({}, b, a); |
| }); |
| |
| /** |
| * Transfer strategies dictate how props are transferred by `transferPropsTo`. |
| * NOTE: if you add any more exceptions to this list you should be sure to |
| * update `cloneWithProps()` accordingly. |
| */ |
| var TransferStrategies = { |
| /** |
| * Never transfer `children`. |
| */ |
| children: emptyFunction, |
| /** |
| * Transfer the `className` prop by merging them. |
| */ |
| className: createTransferStrategy(joinClasses), |
| /** |
| * Transfer the `style` prop (which is an object) by merging them. |
| */ |
| style: transferStrategyMerge |
| }; |
| |
| /** |
| * Mutates the first argument by transferring the properties from the second |
| * argument. |
| * |
| * @param {object} props |
| * @param {object} newProps |
| * @return {object} |
| */ |
| function transferInto(props, newProps) { |
| for (var thisKey in newProps) { |
| if (!newProps.hasOwnProperty(thisKey)) { |
| continue; |
| } |
| |
| var transferStrategy = TransferStrategies[thisKey]; |
| |
| if (transferStrategy && TransferStrategies.hasOwnProperty(thisKey)) { |
| transferStrategy(props, thisKey, newProps[thisKey]); |
| } else if (!props.hasOwnProperty(thisKey)) { |
| props[thisKey] = newProps[thisKey]; |
| } |
| } |
| return props; |
| } |
| |
| /** |
| * ReactPropTransferer are capable of transferring props to another component |
| * using a `transferPropsTo` method. |
| * |
| * @class ReactPropTransferer |
| */ |
| var ReactPropTransferer = { |
| |
| /** |
| * Merge two props objects using TransferStrategies. |
| * |
| * @param {object} oldProps original props (they take precedence) |
| * @param {object} newProps new props to merge in |
| * @return {object} a new object containing both sets of props merged. |
| */ |
| mergeProps: function (oldProps, newProps) { |
| return transferInto(assign({}, oldProps), newProps); |
| } |
| |
| }; |
| |
| module.exports = ReactPropTransferer; |
| },{"153":153,"164":164,"24":24}],80:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactPropTypeLocationNames |
| */ |
| |
| 'use strict'; |
| |
| var ReactPropTypeLocationNames = {}; |
| |
| if ("development" !== 'production') { |
| ReactPropTypeLocationNames = { |
| prop: 'prop', |
| context: 'context', |
| childContext: 'child context' |
| }; |
| } |
| |
| module.exports = ReactPropTypeLocationNames; |
| },{}],81:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactPropTypeLocations |
| */ |
| |
| 'use strict'; |
| |
| var keyMirror = _dereq_(165); |
| |
| var ReactPropTypeLocations = keyMirror({ |
| prop: null, |
| context: null, |
| childContext: null |
| }); |
| |
| module.exports = ReactPropTypeLocations; |
| },{"165":165}],82:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactPropTypes |
| */ |
| |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| var ReactPropTypeLocationNames = _dereq_(80); |
| |
| var emptyFunction = _dereq_(153); |
| var getIteratorFn = _dereq_(129); |
| |
| /** |
| * Collection of methods that allow declaration and validation of props that are |
| * supplied to React components. Example usage: |
| * |
| * var Props = require('ReactPropTypes'); |
| * var MyArticle = React.createClass({ |
| * propTypes: { |
| * // An optional string prop named "description". |
| * description: Props.string, |
| * |
| * // A required enum prop named "category". |
| * category: Props.oneOf(['News','Photos']).isRequired, |
| * |
| * // A prop named "dialog" that requires an instance of Dialog. |
| * dialog: Props.instanceOf(Dialog).isRequired |
| * }, |
| * render: function() { ... } |
| * }); |
| * |
| * A more formal specification of how these methods are used: |
| * |
| * type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...) |
| * decl := ReactPropTypes.{type}(.isRequired)? |
| * |
| * Each and every declaration produces a function with the same signature. This |
| * allows the creation of custom validation functions. For example: |
| * |
| * var MyLink = React.createClass({ |
| * propTypes: { |
| * // An optional string or URI prop named "href". |
| * href: function(props, propName, componentName) { |
| * var propValue = props[propName]; |
| * if (propValue != null && typeof propValue !== 'string' && |
| * !(propValue instanceof URI)) { |
| * return new Error( |
| * 'Expected a string or an URI for ' + propName + ' in ' + |
| * componentName |
| * ); |
| * } |
| * } |
| * }, |
| * render: function() {...} |
| * }); |
| * |
| * @internal |
| */ |
| |
| var ANONYMOUS = '<<anonymous>>'; |
| |
| var ReactPropTypes = { |
| array: createPrimitiveTypeChecker('array'), |
| bool: createPrimitiveTypeChecker('boolean'), |
| func: createPrimitiveTypeChecker('function'), |
| number: createPrimitiveTypeChecker('number'), |
| object: createPrimitiveTypeChecker('object'), |
| string: createPrimitiveTypeChecker('string'), |
| |
| any: createAnyTypeChecker(), |
| arrayOf: createArrayOfTypeChecker, |
| element: createElementTypeChecker(), |
| instanceOf: createInstanceTypeChecker, |
| node: createNodeChecker(), |
| objectOf: createObjectOfTypeChecker, |
| oneOf: createEnumTypeChecker, |
| oneOfType: createUnionTypeChecker, |
| shape: createShapeTypeChecker |
| }; |
| |
| function createChainableTypeChecker(validate) { |
| function checkType(isRequired, props, propName, componentName, location, propFullName) { |
| componentName = componentName || ANONYMOUS; |
| propFullName = propFullName || propName; |
| if (props[propName] == null) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| if (isRequired) { |
| return new Error('Required ' + locationName + ' `' + propFullName + '` was not specified in ' + ('`' + componentName + '`.')); |
| } |
| return null; |
| } else { |
| return validate(props, propName, componentName, location, propFullName); |
| } |
| } |
| |
| var chainedCheckType = checkType.bind(null, false); |
| chainedCheckType.isRequired = checkType.bind(null, true); |
| |
| return chainedCheckType; |
| } |
| |
| function createPrimitiveTypeChecker(expectedType) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== expectedType) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| // `propValue` being instance of, say, date/regexp, pass the 'object' |
| // check, but we can offer a more precise error message here rather than |
| // 'of type `object`'. |
| var preciseType = getPreciseType(propValue); |
| |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createAnyTypeChecker() { |
| return createChainableTypeChecker(emptyFunction.thatReturns(null)); |
| } |
| |
| function createArrayOfTypeChecker(typeChecker) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| if (!Array.isArray(propValue)) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| var propType = getPropType(propValue); |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.')); |
| } |
| for (var i = 0; i < propValue.length; i++) { |
| var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']'); |
| if (error instanceof Error) { |
| return error; |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createElementTypeChecker() { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (!ReactElement.isValidElement(props[propName])) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a single ReactElement.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createInstanceTypeChecker(expectedClass) { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (!(props[propName] instanceof expectedClass)) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| var expectedClassName = expectedClass.name || ANONYMOUS; |
| var actualClassName = getClassName(props[propName]); |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createEnumTypeChecker(expectedValues) { |
| if (!Array.isArray(expectedValues)) { |
| return createChainableTypeChecker(function () { |
| return new Error('Invalid argument supplied to oneOf, expected an instance of array.'); |
| }); |
| } |
| |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| for (var i = 0; i < expectedValues.length; i++) { |
| if (propValue === expectedValues[i]) { |
| return null; |
| } |
| } |
| |
| var locationName = ReactPropTypeLocationNames[location]; |
| var valuesString = JSON.stringify(expectedValues); |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of value `' + propValue + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.')); |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createObjectOfTypeChecker(typeChecker) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== 'object') { |
| var locationName = ReactPropTypeLocationNames[location]; |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.')); |
| } |
| for (var key in propValue) { |
| if (propValue.hasOwnProperty(key)) { |
| var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key); |
| if (error instanceof Error) { |
| return error; |
| } |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createUnionTypeChecker(arrayOfTypeCheckers) { |
| if (!Array.isArray(arrayOfTypeCheckers)) { |
| return createChainableTypeChecker(function () { |
| return new Error('Invalid argument supplied to oneOfType, expected an instance of array.'); |
| }); |
| } |
| |
| function validate(props, propName, componentName, location, propFullName) { |
| for (var i = 0; i < arrayOfTypeCheckers.length; i++) { |
| var checker = arrayOfTypeCheckers[i]; |
| if (checker(props, propName, componentName, location, propFullName) == null) { |
| return null; |
| } |
| } |
| |
| var locationName = ReactPropTypeLocationNames[location]; |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`.')); |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createNodeChecker() { |
| function validate(props, propName, componentName, location, propFullName) { |
| if (!isNode(props[propName])) { |
| var locationName = ReactPropTypeLocationNames[location]; |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.')); |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function createShapeTypeChecker(shapeTypes) { |
| function validate(props, propName, componentName, location, propFullName) { |
| var propValue = props[propName]; |
| var propType = getPropType(propValue); |
| if (propType !== 'object') { |
| var locationName = ReactPropTypeLocationNames[location]; |
| return new Error('Invalid ' + locationName + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.')); |
| } |
| for (var key in shapeTypes) { |
| var checker = shapeTypes[key]; |
| if (!checker) { |
| continue; |
| } |
| var error = checker(propValue, key, componentName, location, propFullName + '.' + key); |
| if (error) { |
| return error; |
| } |
| } |
| return null; |
| } |
| return createChainableTypeChecker(validate); |
| } |
| |
| function isNode(propValue) { |
| switch (typeof propValue) { |
| case 'number': |
| case 'string': |
| case 'undefined': |
| return true; |
| case 'boolean': |
| return !propValue; |
| case 'object': |
| if (Array.isArray(propValue)) { |
| return propValue.every(isNode); |
| } |
| if (propValue === null || ReactElement.isValidElement(propValue)) { |
| return true; |
| } |
| |
| var iteratorFn = getIteratorFn(propValue); |
| if (iteratorFn) { |
| var iterator = iteratorFn.call(propValue); |
| var step; |
| if (iteratorFn !== propValue.entries) { |
| while (!(step = iterator.next()).done) { |
| if (!isNode(step.value)) { |
| return false; |
| } |
| } |
| } else { |
| // Iterator will provide entry [k,v] tuples rather than values. |
| while (!(step = iterator.next()).done) { |
| var entry = step.value; |
| if (entry) { |
| if (!isNode(entry[1])) { |
| return false; |
| } |
| } |
| } |
| } |
| } else { |
| return false; |
| } |
| |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| // Equivalent of `typeof` but with special handling for array and regexp. |
| function getPropType(propValue) { |
| var propType = typeof propValue; |
| if (Array.isArray(propValue)) { |
| return 'array'; |
| } |
| if (propValue instanceof RegExp) { |
| // Old webkits (at least until Android 4.0) return 'function' rather than |
| // 'object' for typeof a RegExp. We'll normalize this here so that /bla/ |
| // passes PropTypes.object. |
| return 'object'; |
| } |
| return propType; |
| } |
| |
| // This handles more types than `getPropType`. Only used for error messages. |
| // See `createPrimitiveTypeChecker`. |
| function getPreciseType(propValue) { |
| var propType = getPropType(propValue); |
| if (propType === 'object') { |
| if (propValue instanceof Date) { |
| return 'date'; |
| } else if (propValue instanceof RegExp) { |
| return 'regexp'; |
| } |
| } |
| return propType; |
| } |
| |
| // Returns class name of the object, if any. |
| function getClassName(propValue) { |
| if (!propValue.constructor || !propValue.constructor.name) { |
| return '<<anonymous>>'; |
| } |
| return propValue.constructor.name; |
| } |
| |
| module.exports = ReactPropTypes; |
| },{"129":129,"153":153,"57":57,"80":80}],83:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactReconcileTransaction |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var CallbackQueue = _dereq_(6); |
| var PooledClass = _dereq_(25); |
| var ReactBrowserEventEmitter = _dereq_(28); |
| var ReactDOMFeatureFlags = _dereq_(44); |
| var ReactInputSelection = _dereq_(66); |
| var Transaction = _dereq_(113); |
| |
| var assign = _dereq_(24); |
| |
| /** |
| * Ensures that, when possible, the selection range (currently selected text |
| * input) is not disturbed by performing the transaction. |
| */ |
| var SELECTION_RESTORATION = { |
| /** |
| * @return {Selection} Selection information. |
| */ |
| initialize: ReactInputSelection.getSelectionInformation, |
| /** |
| * @param {Selection} sel Selection information returned from `initialize`. |
| */ |
| close: ReactInputSelection.restoreSelection |
| }; |
| |
| /** |
| * Suppresses events (blur/focus) that could be inadvertently dispatched due to |
| * high level DOM manipulations (like temporarily removing a text input from the |
| * DOM). |
| */ |
| var EVENT_SUPPRESSION = { |
| /** |
| * @return {boolean} The enabled status of `ReactBrowserEventEmitter` before |
| * the reconciliation. |
| */ |
| initialize: function () { |
| var currentlyEnabled = ReactBrowserEventEmitter.isEnabled(); |
| ReactBrowserEventEmitter.setEnabled(false); |
| return currentlyEnabled; |
| }, |
| |
| /** |
| * @param {boolean} previouslyEnabled Enabled status of |
| * `ReactBrowserEventEmitter` before the reconciliation occurred. `close` |
| * restores the previous value. |
| */ |
| close: function (previouslyEnabled) { |
| ReactBrowserEventEmitter.setEnabled(previouslyEnabled); |
| } |
| }; |
| |
| /** |
| * Provides a queue for collecting `componentDidMount` and |
| * `componentDidUpdate` callbacks during the the transaction. |
| */ |
| var ON_DOM_READY_QUEUEING = { |
| /** |
| * Initializes the internal `onDOMReady` queue. |
| */ |
| initialize: function () { |
| this.reactMountReady.reset(); |
| }, |
| |
| /** |
| * After DOM is flushed, invoke all registered `onDOMReady` callbacks. |
| */ |
| close: function () { |
| this.reactMountReady.notifyAll(); |
| } |
| }; |
| |
| /** |
| * Executed within the scope of the `Transaction` instance. Consider these as |
| * being member methods, but with an implied ordering while being isolated from |
| * each other. |
| */ |
| var TRANSACTION_WRAPPERS = [SELECTION_RESTORATION, EVENT_SUPPRESSION, ON_DOM_READY_QUEUEING]; |
| |
| /** |
| * 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 |
| */ |
| function ReactReconcileTransaction(forceHTML) { |
| 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 |
| // `ReactTextComponent` checks it in `mountComponent`.` |
| this.renderToStaticMarkup = false; |
| this.reactMountReady = CallbackQueue.getPooled(null); |
| this.useCreateElement = !forceHTML && ReactDOMFeatureFlags.useCreateElement; |
| } |
| |
| var Mixin = { |
| /** |
| * @see Transaction |
| * @abstract |
| * @final |
| * @return {array<object>} List of operation wrap procedures. |
| * TODO: convert to array<TransactionWrapper> |
| */ |
| getTransactionWrappers: function () { |
| return TRANSACTION_WRAPPERS; |
| }, |
| |
| /** |
| * @return {object} The queue to collect `onDOMReady` callbacks with. |
| */ |
| getReactMountReady: function () { |
| return this.reactMountReady; |
| }, |
| |
| /** |
| * `PooledClass` looks for this, and will invoke this before allowing this |
| * instance to be reused. |
| */ |
| destructor: function () { |
| CallbackQueue.release(this.reactMountReady); |
| this.reactMountReady = null; |
| } |
| }; |
| |
| assign(ReactReconcileTransaction.prototype, Transaction.Mixin, Mixin); |
| |
| PooledClass.addPoolingTo(ReactReconcileTransaction); |
| |
| module.exports = ReactReconcileTransaction; |
| },{"113":113,"24":24,"25":25,"28":28,"44":44,"6":6,"66":66}],84:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactReconciler |
| */ |
| |
| 'use strict'; |
| |
| var ReactRef = _dereq_(85); |
| |
| /** |
| * Helper to call ReactRef.attachRefs with this composite component, split out |
| * to avoid allocations in the transaction mount-ready queue. |
| */ |
| function attachRefs() { |
| ReactRef.attachRefs(this, this._currentElement); |
| } |
| |
| var ReactReconciler = { |
| |
| /** |
| * Initializes the component, renders markup, and registers event listeners. |
| * |
| * @param {ReactComponent} internalInstance |
| * @param {string} rootID DOM ID of the root node. |
| * @param {ReactReconcileTransaction|ReactServerRenderingTransaction} transaction |
| * @return {?string} Rendered markup to be inserted into the DOM. |
| * @final |
| * @internal |
| */ |
| mountComponent: function (internalInstance, rootID, transaction, context) { |
| var markup = internalInstance.mountComponent(rootID, transaction, context); |
| if (internalInstance._currentElement && internalInstance._currentElement.ref != null) { |
| transaction.getReactMountReady().enqueue(attachRefs, internalInstance); |
| } |
| return markup; |
| }, |
| |
| /** |
| * Releases any resources allocated by `mountComponent`. |
| * |
| * @final |
| * @internal |
| */ |
| unmountComponent: function (internalInstance) { |
| ReactRef.detachRefs(internalInstance, internalInstance._currentElement); |
| internalInstance.unmountComponent(); |
| }, |
| |
| /** |
| * Update a component using a new element. |
| * |
| * @param {ReactComponent} internalInstance |
| * @param {ReactElement} nextElement |
| * @param {ReactReconcileTransaction} transaction |
| * @param {object} context |
| * @internal |
| */ |
| receiveComponent: function (internalInstance, nextElement, transaction, context) { |
| var prevElement = internalInstance._currentElement; |
| |
| if (nextElement === prevElement && context === internalInstance._context) { |
| // Since elements are immutable after the owner is rendered, |
| // we can do a cheap identity compare here to determine if this is a |
| // superfluous reconcile. It's possible for state to be mutable but such |
| // change should trigger an update of the owner which would recreate |
| // the element. We explicitly check for the existence of an owner since |
| // it's possible for an element created outside a composite to be |
| // deeply mutated and reused. |
| |
| // TODO: Bailing out early is just a perf optimization right? |
| // TODO: Removing the return statement should affect correctness? |
| return; |
| } |
| |
| var refsChanged = ReactRef.shouldUpdateRefs(prevElement, nextElement); |
| |
| if (refsChanged) { |
| ReactRef.detachRefs(internalInstance, prevElement); |
| } |
| |
| internalInstance.receiveComponent(nextElement, transaction, context); |
| |
| if (refsChanged && internalInstance._currentElement && internalInstance._currentElement.ref != null) { |
| transaction.getReactMountReady().enqueue(attachRefs, internalInstance); |
| } |
| }, |
| |
| /** |
| * Flush any dirty changes in a component. |
| * |
| * @param {ReactComponent} internalInstance |
| * @param {ReactReconcileTransaction} transaction |
| * @internal |
| */ |
| performUpdateIfNecessary: function (internalInstance, transaction) { |
| internalInstance.performUpdateIfNecessary(transaction); |
| } |
| |
| }; |
| |
| module.exports = ReactReconciler; |
| },{"85":85}],85:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactRef |
| */ |
| |
| 'use strict'; |
| |
| var ReactOwner = _dereq_(77); |
| |
| var ReactRef = {}; |
| |
| function attachRef(ref, component, owner) { |
| if (typeof ref === 'function') { |
| ref(component.getPublicInstance()); |
| } else { |
| // Legacy ref |
| ReactOwner.addComponentAsRefTo(component, ref, owner); |
| } |
| } |
| |
| function detachRef(ref, component, owner) { |
| if (typeof ref === 'function') { |
| ref(null); |
| } else { |
| // Legacy ref |
| ReactOwner.removeComponentAsRefFrom(component, ref, owner); |
| } |
| } |
| |
| ReactRef.attachRefs = function (instance, element) { |
| if (element === null || element === false) { |
| return; |
| } |
| var ref = element.ref; |
| if (ref != null) { |
| attachRef(ref, instance, element._owner); |
| } |
| }; |
| |
| ReactRef.shouldUpdateRefs = function (prevElement, nextElement) { |
| // If either the owner or a `ref` has changed, make sure the newest owner |
| // has stored a reference to `this`, and the previous owner (if different) |
| // has forgotten the reference to `this`. We use the element instead |
| // of the public this.props because the post processing cannot determine |
| // a ref. The ref conceptually lives on the element. |
| |
| // TODO: Should this even be possible? The owner cannot change because |
| // it's forbidden by shouldUpdateReactComponent. The ref can change |
| // if you swap the keys of but not the refs. Reconsider where this check |
| // is made. It probably belongs where the key checking and |
| // instantiateReactComponent is done. |
| |
| var prevEmpty = prevElement === null || prevElement === false; |
| var nextEmpty = nextElement === null || nextElement === false; |
| |
| return( |
| // This has a few false positives w/r/t empty components. |
| prevEmpty || nextEmpty || nextElement._owner !== prevElement._owner || nextElement.ref !== prevElement.ref |
| ); |
| }; |
| |
| ReactRef.detachRefs = function (instance, element) { |
| if (element === null || element === false) { |
| return; |
| } |
| var ref = element.ref; |
| if (ref != null) { |
| detachRef(ref, instance, element._owner); |
| } |
| }; |
| |
| module.exports = ReactRef; |
| },{"77":77}],86:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactRootIndex |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var ReactRootIndexInjection = { |
| /** |
| * @param {function} _createReactRootIndex |
| */ |
| injectCreateReactRootIndex: function (_createReactRootIndex) { |
| ReactRootIndex.createReactRootIndex = _createReactRootIndex; |
| } |
| }; |
| |
| var ReactRootIndex = { |
| createReactRootIndex: null, |
| injection: ReactRootIndexInjection |
| }; |
| |
| module.exports = ReactRootIndex; |
| },{}],87:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactServerBatchingStrategy |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var ReactServerBatchingStrategy = { |
| isBatchingUpdates: false, |
| batchedUpdates: function (callback) { |
| // Don't do anything here. During the server rendering we don't want to |
| // schedule any updates. We will simply ignore them. |
| } |
| }; |
| |
| module.exports = ReactServerBatchingStrategy; |
| },{}],88:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @typechecks static-only |
| * @providesModule ReactServerRendering |
| */ |
| 'use strict'; |
| |
| var ReactDefaultBatchingStrategy = _dereq_(53); |
| var ReactElement = _dereq_(57); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactMarkupChecksum = _dereq_(71); |
| var ReactServerBatchingStrategy = _dereq_(87); |
| var ReactServerRenderingTransaction = _dereq_(89); |
| var ReactUpdates = _dereq_(96); |
| |
| var emptyObject = _dereq_(154); |
| var instantiateReactComponent = _dereq_(132); |
| var invariant = _dereq_(161); |
| |
| /** |
| * @param {ReactElement} element |
| * @return {string} the HTML markup |
| */ |
| function renderToString(element) { |
| !ReactElement.isValidElement(element) ? "development" !== 'production' ? invariant(false, 'renderToString(): You must pass a valid ReactElement.') : invariant(false) : undefined; |
| |
| var transaction; |
| try { |
| ReactUpdates.injection.injectBatchingStrategy(ReactServerBatchingStrategy); |
| |
| var id = ReactInstanceHandles.createReactRootID(); |
| transaction = ReactServerRenderingTransaction.getPooled(false); |
| |
| return transaction.perform(function () { |
| var componentInstance = instantiateReactComponent(element, null); |
| var markup = componentInstance.mountComponent(id, transaction, emptyObject); |
| return ReactMarkupChecksum.addChecksumToMarkup(markup); |
| }, null); |
| } finally { |
| ReactServerRenderingTransaction.release(transaction); |
| // Revert to the DOM batching strategy since these two renderers |
| // currently share these stateful modules. |
| ReactUpdates.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy); |
| } |
| } |
| |
| /** |
| * @param {ReactElement} element |
| * @return {string} the HTML markup, without the extra React ID and checksum |
| * (for generating static pages) |
| */ |
| function renderToStaticMarkup(element) { |
| !ReactElement.isValidElement(element) ? "development" !== 'production' ? invariant(false, 'renderToStaticMarkup(): You must pass a valid ReactElement.') : invariant(false) : undefined; |
| |
| var transaction; |
| try { |
| ReactUpdates.injection.injectBatchingStrategy(ReactServerBatchingStrategy); |
| |
| var id = ReactInstanceHandles.createReactRootID(); |
| transaction = ReactServerRenderingTransaction.getPooled(true); |
| |
| return transaction.perform(function () { |
| var componentInstance = instantiateReactComponent(element, null); |
| return componentInstance.mountComponent(id, transaction, emptyObject); |
| }, null); |
| } finally { |
| ReactServerRenderingTransaction.release(transaction); |
| // Revert to the DOM batching strategy since these two renderers |
| // currently share these stateful modules. |
| ReactUpdates.injection.injectBatchingStrategy(ReactDefaultBatchingStrategy); |
| } |
| } |
| |
| module.exports = { |
| renderToString: renderToString, |
| renderToStaticMarkup: renderToStaticMarkup |
| }; |
| },{"132":132,"154":154,"161":161,"53":53,"57":57,"67":67,"71":71,"87":87,"89":89,"96":96}],89:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactServerRenderingTransaction |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var PooledClass = _dereq_(25); |
| var CallbackQueue = _dereq_(6); |
| var Transaction = _dereq_(113); |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| |
| /** |
| * Provides a `CallbackQueue` queue for collecting `onDOMReady` callbacks |
| * during the performing of the transaction. |
| */ |
| var ON_DOM_READY_QUEUEING = { |
| /** |
| * Initializes the internal `onDOMReady` queue. |
| */ |
| initialize: function () { |
| this.reactMountReady.reset(); |
| }, |
| |
| close: emptyFunction |
| }; |
| |
| /** |
| * Executed within the scope of the `Transaction` instance. Consider these as |
| * being member methods, but with an implied ordering while being isolated from |
| * each other. |
| */ |
| var TRANSACTION_WRAPPERS = [ON_DOM_READY_QUEUEING]; |
| |
| /** |
| * @class ReactServerRenderingTransaction |
| * @param {boolean} renderToStaticMarkup |
| */ |
| function ReactServerRenderingTransaction(renderToStaticMarkup) { |
| this.reinitializeTransaction(); |
| this.renderToStaticMarkup = renderToStaticMarkup; |
| this.reactMountReady = CallbackQueue.getPooled(null); |
| this.useCreateElement = false; |
| } |
| |
| var Mixin = { |
| /** |
| * @see Transaction |
| * @abstract |
| * @final |
| * @return {array} Empty list of operation wrap procedures. |
| */ |
| getTransactionWrappers: function () { |
| return TRANSACTION_WRAPPERS; |
| }, |
| |
| /** |
| * @return {object} The queue to collect `onDOMReady` callbacks with. |
| */ |
| getReactMountReady: function () { |
| return this.reactMountReady; |
| }, |
| |
| /** |
| * `PooledClass` looks for this, and will invoke this before allowing this |
| * instance to be reused. |
| */ |
| destructor: function () { |
| CallbackQueue.release(this.reactMountReady); |
| this.reactMountReady = null; |
| } |
| }; |
| |
| assign(ReactServerRenderingTransaction.prototype, Transaction.Mixin, Mixin); |
| |
| PooledClass.addPoolingTo(ReactServerRenderingTransaction); |
| |
| module.exports = ReactServerRenderingTransaction; |
| },{"113":113,"153":153,"24":24,"25":25,"6":6}],90:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactStateSetters |
| */ |
| |
| 'use strict'; |
| |
| var ReactStateSetters = { |
| /** |
| * Returns a function that calls the provided function, and uses the result |
| * of that to set the component's state. |
| * |
| * @param {ReactCompositeComponent} component |
| * @param {function} funcReturningState Returned callback uses this to |
| * determine how to update state. |
| * @return {function} callback that when invoked uses funcReturningState to |
| * determined the object literal to setState. |
| */ |
| createStateSetter: function (component, funcReturningState) { |
| return function (a, b, c, d, e, f) { |
| var partialState = funcReturningState.call(component, a, b, c, d, e, f); |
| if (partialState) { |
| component.setState(partialState); |
| } |
| }; |
| }, |
| |
| /** |
| * Returns a single-argument callback that can be used to update a single |
| * key in the component's state. |
| * |
| * Note: this is memoized function, which makes it inexpensive to call. |
| * |
| * @param {ReactCompositeComponent} component |
| * @param {string} key The key in the state that you should update. |
| * @return {function} callback of 1 argument which calls setState() with |
| * the provided keyName and callback argument. |
| */ |
| createStateKeySetter: function (component, key) { |
| // Memoize the setters. |
| var cache = component.__keySetters || (component.__keySetters = {}); |
| return cache[key] || (cache[key] = createStateKeySetter(component, key)); |
| } |
| }; |
| |
| function createStateKeySetter(component, key) { |
| // Partial state is allocated outside of the function closure so it can be |
| // reused with every call, avoiding memory allocation when this function |
| // is called. |
| var partialState = {}; |
| return function stateKeySetter(value) { |
| partialState[key] = value; |
| component.setState(partialState); |
| }; |
| } |
| |
| ReactStateSetters.Mixin = { |
| /** |
| * Returns a function that calls the provided function, and uses the result |
| * of that to set the component's state. |
| * |
| * For example, these statements are equivalent: |
| * |
| * this.setState({x: 1}); |
| * this.createStateSetter(function(xValue) { |
| * return {x: xValue}; |
| * })(1); |
| * |
| * @param {function} funcReturningState Returned callback uses this to |
| * determine how to update state. |
| * @return {function} callback that when invoked uses funcReturningState to |
| * determined the object literal to setState. |
| */ |
| createStateSetter: function (funcReturningState) { |
| return ReactStateSetters.createStateSetter(this, funcReturningState); |
| }, |
| |
| /** |
| * Returns a single-argument callback that can be used to update a single |
| * key in the component's state. |
| * |
| * For example, these statements are equivalent: |
| * |
| * this.setState({x: 1}); |
| * this.createStateKeySetter('x')(1); |
| * |
| * Note: this is memoized function, which makes it inexpensive to call. |
| * |
| * @param {string} key The key in the state that you should update. |
| * @return {function} callback of 1 argument which calls setState() with |
| * the provided keyName and callback argument. |
| */ |
| createStateKeySetter: function (key) { |
| return ReactStateSetters.createStateKeySetter(this, key); |
| } |
| }; |
| |
| module.exports = ReactStateSetters; |
| },{}],91:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactTestUtils |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPluginHub = _dereq_(16); |
| var EventPropagators = _dereq_(19); |
| var React = _dereq_(26); |
| var ReactDOM = _dereq_(40); |
| var ReactElement = _dereq_(57); |
| var ReactBrowserEventEmitter = _dereq_(28); |
| var ReactCompositeComponent = _dereq_(38); |
| var ReactInstanceHandles = _dereq_(67); |
| var ReactInstanceMap = _dereq_(68); |
| var ReactMount = _dereq_(72); |
| var ReactUpdates = _dereq_(96); |
| var SyntheticEvent = _dereq_(105); |
| |
| var assign = _dereq_(24); |
| var emptyObject = _dereq_(154); |
| var findDOMNode = _dereq_(122); |
| var invariant = _dereq_(161); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| function Event(suffix) {} |
| |
| /** |
| * @class ReactTestUtils |
| */ |
| |
| function findAllInRenderedTreeInternal(inst, test) { |
| if (!inst || !inst.getPublicInstance) { |
| return []; |
| } |
| var publicInst = inst.getPublicInstance(); |
| var ret = test(publicInst) ? [publicInst] : []; |
| var currentElement = inst._currentElement; |
| if (ReactTestUtils.isDOMComponent(publicInst)) { |
| var renderedChildren = inst._renderedChildren; |
| var key; |
| for (key in renderedChildren) { |
| if (!renderedChildren.hasOwnProperty(key)) { |
| continue; |
| } |
| ret = ret.concat(findAllInRenderedTreeInternal(renderedChildren[key], test)); |
| } |
| } else if (ReactElement.isValidElement(currentElement) && typeof currentElement.type === 'function') { |
| ret = ret.concat(findAllInRenderedTreeInternal(inst._renderedComponent, test)); |
| } |
| return ret; |
| } |
| |
| /** |
| * Todo: Support the entire DOM.scry query syntax. For now, these simple |
| * utilities will suffice for testing purposes. |
| * @lends ReactTestUtils |
| */ |
| var ReactTestUtils = { |
| renderIntoDocument: function (instance) { |
| var div = document.createElement('div'); |
| // None of our tests actually require attaching the container to the |
| // DOM, and doing so creates a mess that we rely on test isolation to |
| // clean up, so we're going to stop honoring the name of this method |
| // (and probably rename it eventually) if no problems arise. |
| // document.documentElement.appendChild(div); |
| return ReactDOM.render(instance, div); |
| }, |
| |
| isElement: function (element) { |
| return ReactElement.isValidElement(element); |
| }, |
| |
| isElementOfType: function (inst, convenienceConstructor) { |
| return ReactElement.isValidElement(inst) && inst.type === convenienceConstructor; |
| }, |
| |
| isDOMComponent: function (inst) { |
| return !!(inst && inst.nodeType === 1 && inst.tagName); |
| }, |
| |
| isDOMComponentElement: function (inst) { |
| return !!(inst && ReactElement.isValidElement(inst) && !!inst.tagName); |
| }, |
| |
| isCompositeComponent: function (inst) { |
| if (ReactTestUtils.isDOMComponent(inst)) { |
| // Accessing inst.setState warns; just return false as that'll be what |
| // this returns when we have DOM nodes as refs directly |
| return false; |
| } |
| return inst != null && typeof inst.render === 'function' && typeof inst.setState === 'function'; |
| }, |
| |
| isCompositeComponentWithType: function (inst, type) { |
| if (!ReactTestUtils.isCompositeComponent(inst)) { |
| return false; |
| } |
| var internalInstance = ReactInstanceMap.get(inst); |
| var constructor = internalInstance._currentElement.type; |
| |
| return constructor === type; |
| }, |
| |
| isCompositeComponentElement: function (inst) { |
| if (!ReactElement.isValidElement(inst)) { |
| return false; |
| } |
| // We check the prototype of the type that will get mounted, not the |
| // instance itself. This is a future proof way of duck typing. |
| var prototype = inst.type.prototype; |
| return typeof prototype.render === 'function' && typeof prototype.setState === 'function'; |
| }, |
| |
| isCompositeComponentElementWithType: function (inst, type) { |
| var internalInstance = ReactInstanceMap.get(inst); |
| var constructor = internalInstance._currentElement.type; |
| |
| return !!(ReactTestUtils.isCompositeComponentElement(inst) && constructor === type); |
| }, |
| |
| getRenderedChildOfCompositeComponent: function (inst) { |
| if (!ReactTestUtils.isCompositeComponent(inst)) { |
| return null; |
| } |
| var internalInstance = ReactInstanceMap.get(inst); |
| return internalInstance._renderedComponent.getPublicInstance(); |
| }, |
| |
| findAllInRenderedTree: function (inst, test) { |
| if (!inst) { |
| return []; |
| } |
| !ReactTestUtils.isCompositeComponent(inst) ? "development" !== 'production' ? invariant(false, 'findAllInRenderedTree(...): instance must be a composite component') : invariant(false) : undefined; |
| return findAllInRenderedTreeInternal(ReactInstanceMap.get(inst), test); |
| }, |
| |
| /** |
| * Finds all instance of components in the rendered tree that are DOM |
| * components with the class name matching `className`. |
| * @return {array} an array of all the matches. |
| */ |
| scryRenderedDOMComponentsWithClass: function (root, classNames) { |
| if (!Array.isArray(classNames)) { |
| classNames = classNames.split(/\s+/); |
| } |
| return ReactTestUtils.findAllInRenderedTree(root, function (inst) { |
| if (ReactTestUtils.isDOMComponent(inst)) { |
| var className = inst.className; |
| if (typeof className !== 'string') { |
| // SVG, probably. |
| className = inst.getAttribute('class') || ''; |
| } |
| var classList = className.split(/\s+/); |
| return classNames.every(function (name) { |
| return classList.indexOf(name) !== -1; |
| }); |
| } |
| return false; |
| }); |
| }, |
| |
| /** |
| * Like scryRenderedDOMComponentsWithClass but expects there to be one result, |
| * and returns that one result, or throws exception if there is any other |
| * number of matches besides one. |
| * @return {!ReactDOMComponent} The one match. |
| */ |
| findRenderedDOMComponentWithClass: function (root, className) { |
| var all = ReactTestUtils.scryRenderedDOMComponentsWithClass(root, className); |
| if (all.length !== 1) { |
| throw new Error('Did not find exactly one match ' + '(found: ' + all.length + ') for class:' + className); |
| } |
| return all[0]; |
| }, |
| |
| /** |
| * Finds all instance of components in the rendered tree that are DOM |
| * components with the tag name matching `tagName`. |
| * @return {array} an array of all the matches. |
| */ |
| scryRenderedDOMComponentsWithTag: function (root, tagName) { |
| return ReactTestUtils.findAllInRenderedTree(root, function (inst) { |
| return ReactTestUtils.isDOMComponent(inst) && inst.tagName.toUpperCase() === tagName.toUpperCase(); |
| }); |
| }, |
| |
| /** |
| * Like scryRenderedDOMComponentsWithTag but expects there to be one result, |
| * and returns that one result, or throws exception if there is any other |
| * number of matches besides one. |
| * @return {!ReactDOMComponent} The one match. |
| */ |
| findRenderedDOMComponentWithTag: function (root, tagName) { |
| var all = ReactTestUtils.scryRenderedDOMComponentsWithTag(root, tagName); |
| if (all.length !== 1) { |
| throw new Error('Did not find exactly one match for tag:' + tagName); |
| } |
| return all[0]; |
| }, |
| |
| /** |
| * Finds all instances of components with type equal to `componentType`. |
| * @return {array} an array of all the matches. |
| */ |
| scryRenderedComponentsWithType: function (root, componentType) { |
| return ReactTestUtils.findAllInRenderedTree(root, function (inst) { |
| return ReactTestUtils.isCompositeComponentWithType(inst, componentType); |
| }); |
| }, |
| |
| /** |
| * Same as `scryRenderedComponentsWithType` but expects there to be one result |
| * and returns that one result, or throws exception if there is any other |
| * number of matches besides one. |
| * @return {!ReactComponent} The one match. |
| */ |
| findRenderedComponentWithType: function (root, componentType) { |
| var all = ReactTestUtils.scryRenderedComponentsWithType(root, componentType); |
| if (all.length !== 1) { |
| throw new Error('Did not find exactly one match for componentType:' + componentType + ' (found ' + all.length + ')'); |
| } |
| return all[0]; |
| }, |
| |
| /** |
| * Pass a mocked component module to this method to augment it with |
| * useful methods that allow it to be used as a dummy React component. |
| * Instead of rendering as usual, the component will become a simple |
| * <div> containing any provided children. |
| * |
| * @param {object} module the mock function object exported from a |
| * module that defines the component to be mocked |
| * @param {?string} mockTagName optional dummy root tag name to return |
| * from render method (overrides |
| * module.mockTagName if provided) |
| * @return {object} the ReactTestUtils object (for chaining) |
| */ |
| mockComponent: function (module, mockTagName) { |
| mockTagName = mockTagName || module.mockTagName || 'div'; |
| |
| module.prototype.render.mockImplementation(function () { |
| return React.createElement(mockTagName, null, this.props.children); |
| }); |
| |
| return this; |
| }, |
| |
| /** |
| * Simulates a top level event being dispatched from a raw event that occurred |
| * on an `Element` node. |
| * @param {Object} topLevelType A type from `EventConstants.topLevelTypes` |
| * @param {!Element} node The dom to simulate an event occurring on. |
| * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent. |
| */ |
| simulateNativeEventOnNode: function (topLevelType, node, fakeNativeEvent) { |
| fakeNativeEvent.target = node; |
| ReactBrowserEventEmitter.ReactEventListener.dispatchEvent(topLevelType, fakeNativeEvent); |
| }, |
| |
| /** |
| * Simulates a top level event being dispatched from a raw event that occurred |
| * on the `ReactDOMComponent` `comp`. |
| * @param {Object} topLevelType A type from `EventConstants.topLevelTypes`. |
| * @param {!ReactDOMComponent} comp |
| * @param {?Event} fakeNativeEvent Fake native event to use in SyntheticEvent. |
| */ |
| simulateNativeEventOnDOMComponent: function (topLevelType, comp, fakeNativeEvent) { |
| ReactTestUtils.simulateNativeEventOnNode(topLevelType, findDOMNode(comp), fakeNativeEvent); |
| }, |
| |
| nativeTouchData: function (x, y) { |
| return { |
| touches: [{ pageX: x, pageY: y }] |
| }; |
| }, |
| |
| createRenderer: function () { |
| return new ReactShallowRenderer(); |
| }, |
| |
| Simulate: null, |
| SimulateNative: {} |
| }; |
| |
| /** |
| * @class ReactShallowRenderer |
| */ |
| var ReactShallowRenderer = function () { |
| this._instance = null; |
| }; |
| |
| ReactShallowRenderer.prototype.getRenderOutput = function () { |
| return this._instance && this._instance._renderedComponent && this._instance._renderedComponent._renderedOutput || null; |
| }; |
| |
| var NoopInternalComponent = function (element) { |
| this._renderedOutput = element; |
| this._currentElement = element; |
| }; |
| |
| NoopInternalComponent.prototype = { |
| |
| mountComponent: function () {}, |
| |
| receiveComponent: function (element) { |
| this._renderedOutput = element; |
| this._currentElement = element; |
| }, |
| |
| unmountComponent: function () {} |
| |
| }; |
| |
| var ShallowComponentWrapper = function () {}; |
| assign(ShallowComponentWrapper.prototype, ReactCompositeComponent.Mixin, { |
| _instantiateReactComponent: function (element) { |
| return new NoopInternalComponent(element); |
| }, |
| _replaceNodeWithMarkupByID: function () {}, |
| _renderValidatedComponent: ReactCompositeComponent.Mixin._renderValidatedComponentWithoutOwnerOrContext |
| }); |
| |
| ReactShallowRenderer.prototype.render = function (element, context) { |
| !ReactElement.isValidElement(element) ? "development" !== 'production' ? invariant(false, 'ReactShallowRenderer render(): Invalid component element.%s', typeof element === 'function' ? ' Instead of passing a component class, make sure to instantiate ' + 'it by passing it to React.createElement.' : '') : invariant(false) : undefined; |
| !(typeof element.type !== 'string') ? "development" !== 'production' ? invariant(false, 'ReactShallowRenderer render(): Shallow rendering works only with custom ' + 'components, not primitives (%s). Instead of calling `.render(el)` and ' + 'inspecting the rendered output, look at `el.props` directly instead.', element.type) : invariant(false) : undefined; |
| |
| if (!context) { |
| context = emptyObject; |
| } |
| var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(false); |
| this._render(element, transaction, context); |
| ReactUpdates.ReactReconcileTransaction.release(transaction); |
| }; |
| |
| ReactShallowRenderer.prototype.unmount = function () { |
| if (this._instance) { |
| this._instance.unmountComponent(); |
| } |
| }; |
| |
| ReactShallowRenderer.prototype._render = function (element, transaction, context) { |
| if (this._instance) { |
| this._instance.receiveComponent(element, transaction, context); |
| } else { |
| var rootID = ReactInstanceHandles.createReactRootID(); |
| var instance = new ShallowComponentWrapper(element.type); |
| instance.construct(element); |
| |
| instance.mountComponent(rootID, transaction, context); |
| |
| this._instance = instance; |
| } |
| }; |
| |
| /** |
| * Exports: |
| * |
| * - `ReactTestUtils.Simulate.click(Element/ReactDOMComponent)` |
| * - `ReactTestUtils.Simulate.mouseMove(Element/ReactDOMComponent)` |
| * - `ReactTestUtils.Simulate.change(Element/ReactDOMComponent)` |
| * - ... (All keys from event plugin `eventTypes` objects) |
| */ |
| function makeSimulator(eventType) { |
| return function (domComponentOrNode, eventData) { |
| var node; |
| if (ReactTestUtils.isDOMComponent(domComponentOrNode)) { |
| node = findDOMNode(domComponentOrNode); |
| } else if (domComponentOrNode.tagName) { |
| node = domComponentOrNode; |
| } |
| |
| var dispatchConfig = ReactBrowserEventEmitter.eventNameDispatchConfigs[eventType]; |
| |
| var fakeNativeEvent = new Event(); |
| fakeNativeEvent.target = node; |
| // We don't use SyntheticEvent.getPooled in order to not have to worry about |
| // properly destroying any properties assigned from `eventData` upon release |
| var event = new SyntheticEvent(dispatchConfig, ReactMount.getID(node), fakeNativeEvent, node); |
| assign(event, eventData); |
| |
| if (dispatchConfig.phasedRegistrationNames) { |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| } else { |
| EventPropagators.accumulateDirectDispatches(event); |
| } |
| |
| ReactUpdates.batchedUpdates(function () { |
| EventPluginHub.enqueueEvents(event); |
| EventPluginHub.processEventQueue(true); |
| }); |
| }; |
| } |
| |
| function buildSimulators() { |
| ReactTestUtils.Simulate = {}; |
| |
| var eventType; |
| for (eventType in ReactBrowserEventEmitter.eventNameDispatchConfigs) { |
| /** |
| * @param {!Element|ReactDOMComponent} domComponentOrNode |
| * @param {?object} eventData Fake event data to use in SyntheticEvent. |
| */ |
| ReactTestUtils.Simulate[eventType] = makeSimulator(eventType); |
| } |
| } |
| |
| // Rebuild ReactTestUtils.Simulate whenever event plugins are injected |
| var oldInjectEventPluginOrder = EventPluginHub.injection.injectEventPluginOrder; |
| EventPluginHub.injection.injectEventPluginOrder = function () { |
| oldInjectEventPluginOrder.apply(this, arguments); |
| buildSimulators(); |
| }; |
| var oldInjectEventPlugins = EventPluginHub.injection.injectEventPluginsByName; |
| EventPluginHub.injection.injectEventPluginsByName = function () { |
| oldInjectEventPlugins.apply(this, arguments); |
| buildSimulators(); |
| }; |
| |
| buildSimulators(); |
| |
| /** |
| * Exports: |
| * |
| * - `ReactTestUtils.SimulateNative.click(Element/ReactDOMComponent)` |
| * - `ReactTestUtils.SimulateNative.mouseMove(Element/ReactDOMComponent)` |
| * - `ReactTestUtils.SimulateNative.mouseIn/ReactDOMComponent)` |
| * - `ReactTestUtils.SimulateNative.mouseOut(Element/ReactDOMComponent)` |
| * - ... (All keys from `EventConstants.topLevelTypes`) |
| * |
| * Note: Top level event types are a subset of the entire set of handler types |
| * (which include a broader set of "synthetic" events). For example, onDragDone |
| * is a synthetic event. Except when testing an event plugin or React's event |
| * handling code specifically, you probably want to use ReactTestUtils.Simulate |
| * to dispatch synthetic events. |
| */ |
| |
| function makeNativeSimulator(eventType) { |
| return function (domComponentOrNode, nativeEventData) { |
| var fakeNativeEvent = new Event(eventType); |
| assign(fakeNativeEvent, nativeEventData); |
| if (ReactTestUtils.isDOMComponent(domComponentOrNode)) { |
| ReactTestUtils.simulateNativeEventOnDOMComponent(eventType, domComponentOrNode, fakeNativeEvent); |
| } else if (domComponentOrNode.tagName) { |
| // Will allow on actual dom nodes. |
| ReactTestUtils.simulateNativeEventOnNode(eventType, domComponentOrNode, fakeNativeEvent); |
| } |
| }; |
| } |
| |
| Object.keys(topLevelTypes).forEach(function (eventType) { |
| // Event type is stored as 'topClick' - we transform that to 'click' |
| var convenienceName = eventType.indexOf('top') === 0 ? eventType.charAt(3).toLowerCase() + eventType.substr(4) : eventType; |
| /** |
| * @param {!Element|ReactDOMComponent} domComponentOrNode |
| * @param {?Event} nativeEventData Fake native event to use in SyntheticEvent. |
| */ |
| ReactTestUtils.SimulateNative[convenienceName] = makeNativeSimulator(eventType); |
| }); |
| |
| module.exports = ReactTestUtils; |
| },{"105":105,"122":122,"15":15,"154":154,"16":16,"161":161,"19":19,"24":24,"26":26,"28":28,"38":38,"40":40,"57":57,"67":67,"68":68,"72":72,"96":96}],92:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @typechecks static-only |
| * @providesModule ReactTransitionChildMapping |
| */ |
| |
| 'use strict'; |
| |
| var flattenChildren = _dereq_(123); |
| |
| var ReactTransitionChildMapping = { |
| /** |
| * Given `this.props.children`, return an object mapping key to child. Just |
| * simple syntactic sugar around flattenChildren(). |
| * |
| * @param {*} children `this.props.children` |
| * @return {object} Mapping of key to child |
| */ |
| getChildMapping: function (children) { |
| if (!children) { |
| return children; |
| } |
| return flattenChildren(children); |
| }, |
| |
| /** |
| * When you're adding or removing children some may be added or removed in the |
| * same render pass. We want to show *both* since we want to simultaneously |
| * animate elements in and out. This function takes a previous set of keys |
| * and a new set of keys and merges them with its best guess of the correct |
| * ordering. In the future we may expose some of the utilities in |
| * ReactMultiChild to make this easy, but for now React itself does not |
| * directly have this concept of the union of prevChildren and nextChildren |
| * so we implement it here. |
| * |
| * @param {object} prev prev children as returned from |
| * `ReactTransitionChildMapping.getChildMapping()`. |
| * @param {object} next next children as returned from |
| * `ReactTransitionChildMapping.getChildMapping()`. |
| * @return {object} a key set that contains all keys in `prev` and all keys |
| * in `next` in a reasonable order. |
| */ |
| mergeChildMappings: function (prev, next) { |
| prev = prev || {}; |
| next = next || {}; |
| |
| function getValueForKey(key) { |
| if (next.hasOwnProperty(key)) { |
| return next[key]; |
| } else { |
| return prev[key]; |
| } |
| } |
| |
| // For each key of `next`, the list of keys to insert before that key in |
| // the combined list |
| var nextKeysPending = {}; |
| |
| var pendingKeys = []; |
| for (var prevKey in prev) { |
| if (next.hasOwnProperty(prevKey)) { |
| if (pendingKeys.length) { |
| nextKeysPending[prevKey] = pendingKeys; |
| pendingKeys = []; |
| } |
| } else { |
| pendingKeys.push(prevKey); |
| } |
| } |
| |
| var i; |
| var childMapping = {}; |
| for (var nextKey in next) { |
| if (nextKeysPending.hasOwnProperty(nextKey)) { |
| for (i = 0; i < nextKeysPending[nextKey].length; i++) { |
| var pendingNextKey = nextKeysPending[nextKey][i]; |
| childMapping[nextKeysPending[nextKey][i]] = getValueForKey(pendingNextKey); |
| } |
| } |
| childMapping[nextKey] = getValueForKey(nextKey); |
| } |
| |
| // Finally, add the keys which didn't appear before any key in `next` |
| for (i = 0; i < pendingKeys.length; i++) { |
| childMapping[pendingKeys[i]] = getValueForKey(pendingKeys[i]); |
| } |
| |
| return childMapping; |
| } |
| }; |
| |
| module.exports = ReactTransitionChildMapping; |
| },{"123":123}],93:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactTransitionEvents |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| /** |
| * EVENT_NAME_MAP is used to determine which event fired when a |
| * transition/animation ends, based on the style property used to |
| * define that event. |
| */ |
| var EVENT_NAME_MAP = { |
| transitionend: { |
| 'transition': 'transitionend', |
| 'WebkitTransition': 'webkitTransitionEnd', |
| 'MozTransition': 'mozTransitionEnd', |
| 'OTransition': 'oTransitionEnd', |
| 'msTransition': 'MSTransitionEnd' |
| }, |
| |
| animationend: { |
| 'animation': 'animationend', |
| 'WebkitAnimation': 'webkitAnimationEnd', |
| 'MozAnimation': 'mozAnimationEnd', |
| 'OAnimation': 'oAnimationEnd', |
| 'msAnimation': 'MSAnimationEnd' |
| } |
| }; |
| |
| var endEvents = []; |
| |
| function detectEvents() { |
| var testEl = document.createElement('div'); |
| var style = testEl.style; |
| |
| // On some platforms, in particular some releases of Android 4.x, |
| // the un-prefixed "animation" and "transition" properties are defined on the |
| // style object but the events that fire will still be prefixed, so we need |
| // to check if the un-prefixed events are useable, and if not remove them |
| // from the map |
| if (!('AnimationEvent' in window)) { |
| delete EVENT_NAME_MAP.animationend.animation; |
| } |
| |
| if (!('TransitionEvent' in window)) { |
| delete EVENT_NAME_MAP.transitionend.transition; |
| } |
| |
| for (var baseEventName in EVENT_NAME_MAP) { |
| var baseEvents = EVENT_NAME_MAP[baseEventName]; |
| for (var styleName in baseEvents) { |
| if (styleName in style) { |
| endEvents.push(baseEvents[styleName]); |
| break; |
| } |
| } |
| } |
| } |
| |
| if (ExecutionEnvironment.canUseDOM) { |
| detectEvents(); |
| } |
| |
| // We use the raw {add|remove}EventListener() call because EventListener |
| // does not know how to remove event listeners and we really should |
| // clean up. Also, these events are not triggered in older browsers |
| // so we should be A-OK here. |
| |
| function addEventListener(node, eventName, eventListener) { |
| node.addEventListener(eventName, eventListener, false); |
| } |
| |
| function removeEventListener(node, eventName, eventListener) { |
| node.removeEventListener(eventName, eventListener, false); |
| } |
| |
| var ReactTransitionEvents = { |
| addEndEventListener: function (node, eventListener) { |
| if (endEvents.length === 0) { |
| // If CSS transitions are not supported, trigger an "end animation" |
| // event immediately. |
| window.setTimeout(eventListener, 0); |
| return; |
| } |
| endEvents.forEach(function (endEvent) { |
| addEventListener(node, endEvent, eventListener); |
| }); |
| }, |
| |
| removeEndEventListener: function (node, eventListener) { |
| if (endEvents.length === 0) { |
| return; |
| } |
| endEvents.forEach(function (endEvent) { |
| removeEventListener(node, endEvent, eventListener); |
| }); |
| } |
| }; |
| |
| module.exports = ReactTransitionEvents; |
| },{"147":147}],94:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactTransitionGroup |
| */ |
| |
| 'use strict'; |
| |
| var React = _dereq_(26); |
| var ReactTransitionChildMapping = _dereq_(92); |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| |
| var ReactTransitionGroup = React.createClass({ |
| displayName: 'ReactTransitionGroup', |
| |
| propTypes: { |
| component: React.PropTypes.any, |
| childFactory: React.PropTypes.func |
| }, |
| |
| getDefaultProps: function () { |
| return { |
| component: 'span', |
| childFactory: emptyFunction.thatReturnsArgument |
| }; |
| }, |
| |
| getInitialState: function () { |
| return { |
| children: ReactTransitionChildMapping.getChildMapping(this.props.children) |
| }; |
| }, |
| |
| componentWillMount: function () { |
| this.currentlyTransitioningKeys = {}; |
| this.keysToEnter = []; |
| this.keysToLeave = []; |
| }, |
| |
| componentDidMount: function () { |
| var initialChildMapping = this.state.children; |
| for (var key in initialChildMapping) { |
| if (initialChildMapping[key]) { |
| this.performAppear(key); |
| } |
| } |
| }, |
| |
| componentWillReceiveProps: function (nextProps) { |
| var nextChildMapping = ReactTransitionChildMapping.getChildMapping(nextProps.children); |
| var prevChildMapping = this.state.children; |
| |
| this.setState({ |
| children: ReactTransitionChildMapping.mergeChildMappings(prevChildMapping, nextChildMapping) |
| }); |
| |
| var key; |
| |
| for (key in nextChildMapping) { |
| var hasPrev = prevChildMapping && prevChildMapping.hasOwnProperty(key); |
| if (nextChildMapping[key] && !hasPrev && !this.currentlyTransitioningKeys[key]) { |
| this.keysToEnter.push(key); |
| } |
| } |
| |
| for (key in prevChildMapping) { |
| var hasNext = nextChildMapping && nextChildMapping.hasOwnProperty(key); |
| if (prevChildMapping[key] && !hasNext && !this.currentlyTransitioningKeys[key]) { |
| this.keysToLeave.push(key); |
| } |
| } |
| |
| // If we want to someday check for reordering, we could do it here. |
| }, |
| |
| componentDidUpdate: function () { |
| var keysToEnter = this.keysToEnter; |
| this.keysToEnter = []; |
| keysToEnter.forEach(this.performEnter); |
| |
| var keysToLeave = this.keysToLeave; |
| this.keysToLeave = []; |
| keysToLeave.forEach(this.performLeave); |
| }, |
| |
| performAppear: function (key) { |
| this.currentlyTransitioningKeys[key] = true; |
| |
| var component = this.refs[key]; |
| |
| if (component.componentWillAppear) { |
| component.componentWillAppear(this._handleDoneAppearing.bind(this, key)); |
| } else { |
| this._handleDoneAppearing(key); |
| } |
| }, |
| |
| _handleDoneAppearing: function (key) { |
| var component = this.refs[key]; |
| if (component.componentDidAppear) { |
| component.componentDidAppear(); |
| } |
| |
| delete this.currentlyTransitioningKeys[key]; |
| |
| var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children); |
| |
| if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) { |
| // This was removed before it had fully appeared. Remove it. |
| this.performLeave(key); |
| } |
| }, |
| |
| performEnter: function (key) { |
| this.currentlyTransitioningKeys[key] = true; |
| |
| var component = this.refs[key]; |
| |
| if (component.componentWillEnter) { |
| component.componentWillEnter(this._handleDoneEntering.bind(this, key)); |
| } else { |
| this._handleDoneEntering(key); |
| } |
| }, |
| |
| _handleDoneEntering: function (key) { |
| var component = this.refs[key]; |
| if (component.componentDidEnter) { |
| component.componentDidEnter(); |
| } |
| |
| delete this.currentlyTransitioningKeys[key]; |
| |
| var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children); |
| |
| if (!currentChildMapping || !currentChildMapping.hasOwnProperty(key)) { |
| // This was removed before it had fully entered. Remove it. |
| this.performLeave(key); |
| } |
| }, |
| |
| performLeave: function (key) { |
| this.currentlyTransitioningKeys[key] = true; |
| |
| var component = this.refs[key]; |
| if (component.componentWillLeave) { |
| component.componentWillLeave(this._handleDoneLeaving.bind(this, key)); |
| } else { |
| // Note that this is somewhat dangerous b/c it calls setState() |
| // again, effectively mutating the component before all the work |
| // is done. |
| this._handleDoneLeaving(key); |
| } |
| }, |
| |
| _handleDoneLeaving: function (key) { |
| var component = this.refs[key]; |
| |
| if (component.componentDidLeave) { |
| component.componentDidLeave(); |
| } |
| |
| delete this.currentlyTransitioningKeys[key]; |
| |
| var currentChildMapping = ReactTransitionChildMapping.getChildMapping(this.props.children); |
| |
| if (currentChildMapping && currentChildMapping.hasOwnProperty(key)) { |
| // This entered again before it fully left. Add it again. |
| this.performEnter(key); |
| } else { |
| this.setState(function (state) { |
| var newChildren = assign({}, state.children); |
| delete newChildren[key]; |
| return { children: newChildren }; |
| }); |
| } |
| }, |
| |
| render: function () { |
| // TODO: we could get rid of the need for the wrapper node |
| // by cloning a single child |
| var childrenToRender = []; |
| for (var key in this.state.children) { |
| var child = this.state.children[key]; |
| if (child) { |
| // You may need to apply reactive updates to a child as it is leaving. |
| // The normal React way to do it won't work since the child will have |
| // already been removed. In case you need this behavior you can provide |
| // a childFactory function to wrap every child, even the ones that are |
| // leaving. |
| childrenToRender.push(React.cloneElement(this.props.childFactory(child), { ref: key, key: key })); |
| } |
| } |
| return React.createElement(this.props.component, this.props, childrenToRender); |
| } |
| }); |
| |
| module.exports = ReactTransitionGroup; |
| },{"153":153,"24":24,"26":26,"92":92}],95:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactUpdateQueue |
| */ |
| |
| 'use strict'; |
| |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactElement = _dereq_(57); |
| var ReactInstanceMap = _dereq_(68); |
| var ReactUpdates = _dereq_(96); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| function enqueueUpdate(internalInstance) { |
| ReactUpdates.enqueueUpdate(internalInstance); |
| } |
| |
| function getInternalInstanceReadyForUpdate(publicInstance, callerName) { |
| var internalInstance = ReactInstanceMap.get(publicInstance); |
| if (!internalInstance) { |
| if ("development" !== 'production') { |
| // Only warn when we have a callerName. Otherwise we should be silent. |
| // We're probably calling from enqueueCallback. We don't want to warn |
| // there because we already warned for the corresponding lifecycle method. |
| "development" !== 'production' ? warning(!callerName, '%s(...): Can only update a mounted or mounting component. ' + 'This usually means you called %s() on an unmounted component. ' + 'This is a no-op. Please check the code for the %s component.', callerName, callerName, publicInstance.constructor.displayName) : undefined; |
| } |
| return null; |
| } |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(ReactCurrentOwner.current == null, '%s(...): Cannot update during an existing state transition ' + '(such as within `render`). Render methods should be a pure function ' + 'of props and state.', callerName) : undefined; |
| } |
| |
| return internalInstance; |
| } |
| |
| /** |
| * ReactUpdateQueue allows for state updates to be scheduled into a later |
| * reconciliation step. |
| */ |
| var ReactUpdateQueue = { |
| |
| /** |
| * Checks whether or not this composite component is mounted. |
| * @param {ReactClass} publicInstance The instance we want to test. |
| * @return {boolean} True if mounted, false otherwise. |
| * @protected |
| * @final |
| */ |
| isMounted: function (publicInstance) { |
| if ("development" !== 'production') { |
| var owner = ReactCurrentOwner.current; |
| if (owner !== null) { |
| "development" !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing isMounted inside its render() function. ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : undefined; |
| owner._warnedAboutRefsInRender = true; |
| } |
| } |
| var internalInstance = ReactInstanceMap.get(publicInstance); |
| if (internalInstance) { |
| // During componentWillMount and render this will still be null but after |
| // that will always render to something. At least for now. So we can use |
| // this hack. |
| return !!internalInstance._renderedComponent; |
| } else { |
| return false; |
| } |
| }, |
| |
| /** |
| * Enqueue a callback that will be executed after all the pending updates |
| * have processed. |
| * |
| * @param {ReactClass} publicInstance The instance to use as `this` context. |
| * @param {?function} callback Called after state is updated. |
| * @internal |
| */ |
| enqueueCallback: function (publicInstance, callback) { |
| !(typeof callback === 'function') ? "development" !== 'production' ? invariant(false, 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(false) : undefined; |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance); |
| |
| // Previously we would throw an error if we didn't have an internal |
| // instance. Since we want to make it a no-op instead, we mirror the same |
| // behavior we have in other enqueue* methods. |
| // We also need to ignore callbacks in componentWillMount. See |
| // enqueueUpdates. |
| if (!internalInstance) { |
| return null; |
| } |
| |
| if (internalInstance._pendingCallbacks) { |
| internalInstance._pendingCallbacks.push(callback); |
| } else { |
| internalInstance._pendingCallbacks = [callback]; |
| } |
| // TODO: The callback here is ignored when setState is called from |
| // componentWillMount. Either fix it or disallow doing so completely in |
| // favor of getInitialState. Alternatively, we can disallow |
| // componentWillMount during server-side rendering. |
| enqueueUpdate(internalInstance); |
| }, |
| |
| enqueueCallbackInternal: function (internalInstance, callback) { |
| !(typeof callback === 'function') ? "development" !== 'production' ? invariant(false, 'enqueueCallback(...): You called `setProps`, `replaceProps`, ' + '`setState`, `replaceState`, or `forceUpdate` with a callback that ' + 'isn\'t callable.') : invariant(false) : undefined; |
| if (internalInstance._pendingCallbacks) { |
| internalInstance._pendingCallbacks.push(callback); |
| } else { |
| internalInstance._pendingCallbacks = [callback]; |
| } |
| enqueueUpdate(internalInstance); |
| }, |
| |
| /** |
| * Forces an update. This should only be invoked when it is known with |
| * certainty that we are **not** in a DOM transaction. |
| * |
| * You may want to call this when you know that some deeper aspect of the |
| * component's state has changed but `setState` was not called. |
| * |
| * This will not invoke `shouldComponentUpdate`, but it will invoke |
| * `componentWillUpdate` and `componentDidUpdate`. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @internal |
| */ |
| enqueueForceUpdate: function (publicInstance) { |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'forceUpdate'); |
| |
| if (!internalInstance) { |
| return; |
| } |
| |
| internalInstance._pendingForceUpdate = true; |
| |
| enqueueUpdate(internalInstance); |
| }, |
| |
| /** |
| * Replaces all of the state. Always use this or `setState` to mutate state. |
| * You should treat `this.state` as immutable. |
| * |
| * There is no guarantee that `this.state` will be immediately updated, so |
| * accessing `this.state` after calling this method may return the old value. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} completeState Next state. |
| * @internal |
| */ |
| enqueueReplaceState: function (publicInstance, completeState) { |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceState'); |
| |
| if (!internalInstance) { |
| return; |
| } |
| |
| internalInstance._pendingStateQueue = [completeState]; |
| internalInstance._pendingReplaceState = true; |
| |
| enqueueUpdate(internalInstance); |
| }, |
| |
| /** |
| * Sets a subset of the state. This only exists because _pendingState is |
| * internal. This provides a merging strategy that is not available to deep |
| * properties which is confusing. TODO: Expose pendingState or don't use it |
| * during the merge. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} partialState Next partial state to be merged with state. |
| * @internal |
| */ |
| enqueueSetState: function (publicInstance, partialState) { |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setState'); |
| |
| if (!internalInstance) { |
| return; |
| } |
| |
| var queue = internalInstance._pendingStateQueue || (internalInstance._pendingStateQueue = []); |
| queue.push(partialState); |
| |
| enqueueUpdate(internalInstance); |
| }, |
| |
| /** |
| * Sets a subset of the props. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} partialProps Subset of the next props. |
| * @internal |
| */ |
| enqueueSetProps: function (publicInstance, partialProps) { |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'setProps'); |
| if (!internalInstance) { |
| return; |
| } |
| ReactUpdateQueue.enqueueSetPropsInternal(internalInstance, partialProps); |
| }, |
| |
| enqueueSetPropsInternal: function (internalInstance, partialProps) { |
| var topLevelWrapper = internalInstance._topLevelWrapper; |
| !topLevelWrapper ? "development" !== 'production' ? invariant(false, 'setProps(...): You called `setProps` on a ' + 'component with a parent. This is an anti-pattern since props will ' + 'get reactively updated when rendered. Instead, change the owner\'s ' + '`render` method to pass the correct value as props to the component ' + 'where it is created.') : invariant(false) : undefined; |
| |
| // Merge with the pending element if it exists, otherwise with existing |
| // element props. |
| var wrapElement = topLevelWrapper._pendingElement || topLevelWrapper._currentElement; |
| var element = wrapElement.props; |
| var props = assign({}, element.props, partialProps); |
| topLevelWrapper._pendingElement = ReactElement.cloneAndReplaceProps(wrapElement, ReactElement.cloneAndReplaceProps(element, props)); |
| |
| enqueueUpdate(topLevelWrapper); |
| }, |
| |
| /** |
| * Replaces all of the props. |
| * |
| * @param {ReactClass} publicInstance The instance that should rerender. |
| * @param {object} props New props. |
| * @internal |
| */ |
| enqueueReplaceProps: function (publicInstance, props) { |
| var internalInstance = getInternalInstanceReadyForUpdate(publicInstance, 'replaceProps'); |
| if (!internalInstance) { |
| return; |
| } |
| ReactUpdateQueue.enqueueReplacePropsInternal(internalInstance, props); |
| }, |
| |
| enqueueReplacePropsInternal: function (internalInstance, props) { |
| var topLevelWrapper = internalInstance._topLevelWrapper; |
| !topLevelWrapper ? "development" !== 'production' ? invariant(false, 'replaceProps(...): You called `replaceProps` on a ' + 'component with a parent. This is an anti-pattern since props will ' + 'get reactively updated when rendered. Instead, change the owner\'s ' + '`render` method to pass the correct value as props to the component ' + 'where it is created.') : invariant(false) : undefined; |
| |
| // Merge with the pending element if it exists, otherwise with existing |
| // element props. |
| var wrapElement = topLevelWrapper._pendingElement || topLevelWrapper._currentElement; |
| var element = wrapElement.props; |
| topLevelWrapper._pendingElement = ReactElement.cloneAndReplaceProps(wrapElement, ReactElement.cloneAndReplaceProps(element, props)); |
| |
| enqueueUpdate(topLevelWrapper); |
| }, |
| |
| enqueueElementInternal: function (internalInstance, newElement) { |
| internalInstance._pendingElement = newElement; |
| enqueueUpdate(internalInstance); |
| } |
| |
| }; |
| |
| module.exports = ReactUpdateQueue; |
| },{"161":161,"173":173,"24":24,"39":39,"57":57,"68":68,"96":96}],96:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactUpdates |
| */ |
| |
| 'use strict'; |
| |
| var CallbackQueue = _dereq_(6); |
| var PooledClass = _dereq_(25); |
| var ReactPerf = _dereq_(78); |
| var ReactReconciler = _dereq_(84); |
| var Transaction = _dereq_(113); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| |
| var dirtyComponents = []; |
| var asapCallbackQueue = CallbackQueue.getPooled(); |
| var asapEnqueued = false; |
| |
| var batchingStrategy = null; |
| |
| function ensureInjected() { |
| !(ReactUpdates.ReactReconcileTransaction && batchingStrategy) ? "development" !== 'production' ? invariant(false, 'ReactUpdates: must inject a reconcile transaction class and batching ' + 'strategy') : invariant(false) : undefined; |
| } |
| |
| var NESTED_UPDATES = { |
| initialize: function () { |
| this.dirtyComponentsLength = dirtyComponents.length; |
| }, |
| close: function () { |
| if (this.dirtyComponentsLength !== dirtyComponents.length) { |
| // Additional updates were enqueued by componentDidUpdate handlers or |
| // similar; before our own UPDATE_QUEUEING wrapper closes, we want to run |
| // these new updates so that if A's componentDidUpdate calls setState on |
| // B, B will update before the callback A's updater provided when calling |
| // setState. |
| dirtyComponents.splice(0, this.dirtyComponentsLength); |
| flushBatchedUpdates(); |
| } else { |
| dirtyComponents.length = 0; |
| } |
| } |
| }; |
| |
| var UPDATE_QUEUEING = { |
| initialize: function () { |
| this.callbackQueue.reset(); |
| }, |
| close: function () { |
| this.callbackQueue.notifyAll(); |
| } |
| }; |
| |
| var TRANSACTION_WRAPPERS = [NESTED_UPDATES, UPDATE_QUEUEING]; |
| |
| function ReactUpdatesFlushTransaction() { |
| this.reinitializeTransaction(); |
| this.dirtyComponentsLength = null; |
| this.callbackQueue = CallbackQueue.getPooled(); |
| this.reconcileTransaction = ReactUpdates.ReactReconcileTransaction.getPooled( /* forceHTML */false); |
| } |
| |
| assign(ReactUpdatesFlushTransaction.prototype, Transaction.Mixin, { |
| getTransactionWrappers: function () { |
| return TRANSACTION_WRAPPERS; |
| }, |
| |
| destructor: function () { |
| this.dirtyComponentsLength = null; |
| CallbackQueue.release(this.callbackQueue); |
| this.callbackQueue = null; |
| ReactUpdates.ReactReconcileTransaction.release(this.reconcileTransaction); |
| this.reconcileTransaction = null; |
| }, |
| |
| perform: function (method, scope, a) { |
| // Essentially calls `this.reconcileTransaction.perform(method, scope, a)` |
| // with this transaction's wrappers around it. |
| return Transaction.Mixin.perform.call(this, this.reconcileTransaction.perform, this.reconcileTransaction, method, scope, a); |
| } |
| }); |
| |
| PooledClass.addPoolingTo(ReactUpdatesFlushTransaction); |
| |
| function batchedUpdates(callback, a, b, c, d, e) { |
| ensureInjected(); |
| batchingStrategy.batchedUpdates(callback, a, b, c, d, e); |
| } |
| |
| /** |
| * 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(). |
| */ |
| function mountOrderComparator(c1, c2) { |
| return c1._mountOrder - c2._mountOrder; |
| } |
| |
| function runBatchedUpdates(transaction) { |
| var len = transaction.dirtyComponentsLength; |
| !(len === dirtyComponents.length) ? "development" !== 'production' ? invariant(false, 'Expected flush transaction\'s stored dirty-components length (%s) to ' + 'match dirty-components array length (%s).', len, dirtyComponents.length) : invariant(false) : undefined; |
| |
| // Since reconciling a component higher in the owner hierarchy usually (not |
| // always -- see shouldComponentUpdate()) will reconcile children, reconcile |
| // them before their children by sorting the array. |
| dirtyComponents.sort(mountOrderComparator); |
| |
| for (var i = 0; i < len; i++) { |
| // If a component is unmounted before pending changes apply, it will still |
| // be here, but we assume that it has cleared its _pendingCallbacks and |
| // that performUpdateIfNecessary is a noop. |
| var component = dirtyComponents[i]; |
| |
| // If performUpdateIfNecessary happens to enqueue any new updates, we |
| // shouldn't execute the callbacks until the next render happens, so |
| // stash the callbacks first |
| var callbacks = component._pendingCallbacks; |
| component._pendingCallbacks = null; |
| |
| ReactReconciler.performUpdateIfNecessary(component, transaction.reconcileTransaction); |
| |
| if (callbacks) { |
| for (var j = 0; j < callbacks.length; j++) { |
| transaction.callbackQueue.enqueue(callbacks[j], component.getPublicInstance()); |
| } |
| } |
| } |
| } |
| |
| var flushBatchedUpdates = function () { |
| // ReactUpdatesFlushTransaction's wrappers will clear the dirtyComponents |
| // array and perform any updates enqueued by mount-ready handlers (i.e., |
| // componentDidUpdate) but we need to check here too in order to catch |
| // updates enqueued by setState callbacks and asap calls. |
| while (dirtyComponents.length || asapEnqueued) { |
| if (dirtyComponents.length) { |
| var transaction = ReactUpdatesFlushTransaction.getPooled(); |
| transaction.perform(runBatchedUpdates, null, transaction); |
| ReactUpdatesFlushTransaction.release(transaction); |
| } |
| |
| if (asapEnqueued) { |
| asapEnqueued = false; |
| var queue = asapCallbackQueue; |
| asapCallbackQueue = CallbackQueue.getPooled(); |
| queue.notifyAll(); |
| CallbackQueue.release(queue); |
| } |
| } |
| }; |
| flushBatchedUpdates = ReactPerf.measure('ReactUpdates', 'flushBatchedUpdates', flushBatchedUpdates); |
| |
| /** |
| * Mark a component as needing a rerender, adding an optional callback to a |
| * list of functions which will be executed once the rerender occurs. |
| */ |
| 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 setProps, 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); |
| } |
| |
| /** |
| * Enqueue a callback to be run at the end of the current batching cycle. Throws |
| * if no updates are currently being performed. |
| */ |
| function asap(callback, context) { |
| !batchingStrategy.isBatchingUpdates ? "development" !== 'production' ? invariant(false, 'ReactUpdates.asap: Can\'t enqueue an asap callback in a context where' + 'updates are not being batched.') : invariant(false) : undefined; |
| asapCallbackQueue.enqueue(callback, context); |
| asapEnqueued = true; |
| } |
| |
| var ReactUpdatesInjection = { |
| injectReconcileTransaction: function (ReconcileTransaction) { |
| !ReconcileTransaction ? "development" !== 'production' ? invariant(false, 'ReactUpdates: must provide a reconcile transaction class') : invariant(false) : undefined; |
| ReactUpdates.ReactReconcileTransaction = ReconcileTransaction; |
| }, |
| |
| injectBatchingStrategy: function (_batchingStrategy) { |
| !_batchingStrategy ? "development" !== 'production' ? invariant(false, 'ReactUpdates: must provide a batching strategy') : invariant(false) : undefined; |
| !(typeof _batchingStrategy.batchedUpdates === 'function') ? "development" !== 'production' ? invariant(false, 'ReactUpdates: must provide a batchedUpdates() function') : invariant(false) : undefined; |
| !(typeof _batchingStrategy.isBatchingUpdates === 'boolean') ? "development" !== 'production' ? invariant(false, 'ReactUpdates: must provide an isBatchingUpdates boolean attribute') : invariant(false) : undefined; |
| batchingStrategy = _batchingStrategy; |
| } |
| }; |
| |
| var ReactUpdates = { |
| /** |
| * React references `ReactReconcileTransaction` using this property in order |
| * to allow dependency injection. |
| * |
| * @internal |
| */ |
| ReactReconcileTransaction: null, |
| |
| batchedUpdates: batchedUpdates, |
| enqueueUpdate: enqueueUpdate, |
| flushBatchedUpdates: flushBatchedUpdates, |
| injection: ReactUpdatesInjection, |
| asap: asap |
| }; |
| |
| module.exports = ReactUpdates; |
| },{"113":113,"161":161,"24":24,"25":25,"6":6,"78":78,"84":84}],97:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ReactVersion |
| */ |
| |
| 'use strict'; |
| |
| module.exports = '0.14.1'; |
| },{}],98:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SVGDOMPropertyConfig |
| */ |
| |
| 'use strict'; |
| |
| var DOMProperty = _dereq_(10); |
| |
| var MUST_USE_ATTRIBUTE = DOMProperty.injection.MUST_USE_ATTRIBUTE; |
| |
| var NS = { |
| xlink: 'http://www.w3.org/1999/xlink', |
| xml: 'http://www.w3.org/XML/1998/namespace' |
| }; |
| |
| var SVGDOMPropertyConfig = { |
| Properties: { |
| clipPath: MUST_USE_ATTRIBUTE, |
| cx: MUST_USE_ATTRIBUTE, |
| cy: MUST_USE_ATTRIBUTE, |
| d: MUST_USE_ATTRIBUTE, |
| dx: MUST_USE_ATTRIBUTE, |
| dy: MUST_USE_ATTRIBUTE, |
| fill: MUST_USE_ATTRIBUTE, |
| fillOpacity: MUST_USE_ATTRIBUTE, |
| fontFamily: MUST_USE_ATTRIBUTE, |
| fontSize: MUST_USE_ATTRIBUTE, |
| fx: MUST_USE_ATTRIBUTE, |
| fy: MUST_USE_ATTRIBUTE, |
| gradientTransform: MUST_USE_ATTRIBUTE, |
| gradientUnits: MUST_USE_ATTRIBUTE, |
| markerEnd: MUST_USE_ATTRIBUTE, |
| markerMid: MUST_USE_ATTRIBUTE, |
| markerStart: MUST_USE_ATTRIBUTE, |
| offset: MUST_USE_ATTRIBUTE, |
| opacity: MUST_USE_ATTRIBUTE, |
| patternContentUnits: MUST_USE_ATTRIBUTE, |
| patternUnits: MUST_USE_ATTRIBUTE, |
| points: MUST_USE_ATTRIBUTE, |
| preserveAspectRatio: MUST_USE_ATTRIBUTE, |
| r: MUST_USE_ATTRIBUTE, |
| rx: MUST_USE_ATTRIBUTE, |
| ry: MUST_USE_ATTRIBUTE, |
| spreadMethod: MUST_USE_ATTRIBUTE, |
| stopColor: MUST_USE_ATTRIBUTE, |
| stopOpacity: MUST_USE_ATTRIBUTE, |
| stroke: MUST_USE_ATTRIBUTE, |
| strokeDasharray: MUST_USE_ATTRIBUTE, |
| strokeLinecap: MUST_USE_ATTRIBUTE, |
| strokeOpacity: MUST_USE_ATTRIBUTE, |
| strokeWidth: MUST_USE_ATTRIBUTE, |
| textAnchor: MUST_USE_ATTRIBUTE, |
| transform: MUST_USE_ATTRIBUTE, |
| version: MUST_USE_ATTRIBUTE, |
| viewBox: MUST_USE_ATTRIBUTE, |
| x1: MUST_USE_ATTRIBUTE, |
| x2: MUST_USE_ATTRIBUTE, |
| x: MUST_USE_ATTRIBUTE, |
| xlinkActuate: MUST_USE_ATTRIBUTE, |
| xlinkArcrole: MUST_USE_ATTRIBUTE, |
| xlinkHref: MUST_USE_ATTRIBUTE, |
| xlinkRole: MUST_USE_ATTRIBUTE, |
| xlinkShow: MUST_USE_ATTRIBUTE, |
| xlinkTitle: MUST_USE_ATTRIBUTE, |
| xlinkType: MUST_USE_ATTRIBUTE, |
| xmlBase: MUST_USE_ATTRIBUTE, |
| xmlLang: MUST_USE_ATTRIBUTE, |
| xmlSpace: MUST_USE_ATTRIBUTE, |
| y1: MUST_USE_ATTRIBUTE, |
| y2: MUST_USE_ATTRIBUTE, |
| y: MUST_USE_ATTRIBUTE |
| }, |
| DOMAttributeNamespaces: { |
| xlinkActuate: NS.xlink, |
| xlinkArcrole: NS.xlink, |
| xlinkHref: NS.xlink, |
| xlinkRole: NS.xlink, |
| xlinkShow: NS.xlink, |
| xlinkTitle: NS.xlink, |
| xlinkType: NS.xlink, |
| xmlBase: NS.xml, |
| xmlLang: NS.xml, |
| xmlSpace: NS.xml |
| }, |
| DOMAttributeNames: { |
| clipPath: 'clip-path', |
| fillOpacity: 'fill-opacity', |
| fontFamily: 'font-family', |
| fontSize: 'font-size', |
| gradientTransform: 'gradientTransform', |
| gradientUnits: 'gradientUnits', |
| markerEnd: 'marker-end', |
| markerMid: 'marker-mid', |
| markerStart: 'marker-start', |
| patternContentUnits: 'patternContentUnits', |
| patternUnits: 'patternUnits', |
| preserveAspectRatio: 'preserveAspectRatio', |
| spreadMethod: 'spreadMethod', |
| stopColor: 'stop-color', |
| stopOpacity: 'stop-opacity', |
| strokeDasharray: 'stroke-dasharray', |
| strokeLinecap: 'stroke-linecap', |
| strokeOpacity: 'stroke-opacity', |
| strokeWidth: 'stroke-width', |
| textAnchor: 'text-anchor', |
| viewBox: 'viewBox', |
| xlinkActuate: 'xlink:actuate', |
| xlinkArcrole: 'xlink:arcrole', |
| xlinkHref: 'xlink:href', |
| xlinkRole: 'xlink:role', |
| xlinkShow: 'xlink:show', |
| xlinkTitle: 'xlink:title', |
| xlinkType: 'xlink:type', |
| xmlBase: 'xml:base', |
| xmlLang: 'xml:lang', |
| xmlSpace: 'xml:space' |
| } |
| }; |
| |
| module.exports = SVGDOMPropertyConfig; |
| },{"10":10}],99:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SelectEventPlugin |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventPropagators = _dereq_(19); |
| var ExecutionEnvironment = _dereq_(147); |
| var ReactInputSelection = _dereq_(66); |
| var SyntheticEvent = _dereq_(105); |
| |
| var getActiveElement = _dereq_(156); |
| var isTextInputElement = _dereq_(134); |
| var keyOf = _dereq_(166); |
| var shallowEqual = _dereq_(171); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| var skipSelectionChangeEvent = ExecutionEnvironment.canUseDOM && 'documentMode' in document && document.documentMode <= 11; |
| |
| var eventTypes = { |
| select: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onSelect: null }), |
| captured: keyOf({ onSelectCapture: null }) |
| }, |
| dependencies: [topLevelTypes.topBlur, topLevelTypes.topContextMenu, topLevelTypes.topFocus, topLevelTypes.topKeyDown, topLevelTypes.topMouseDown, topLevelTypes.topMouseUp, topLevelTypes.topSelectionChange] |
| } |
| }; |
| |
| var activeElement = null; |
| var activeElementID = null; |
| var lastSelection = null; |
| var mouseDown = false; |
| |
| // Track whether a listener exists for this plugin. If none exist, we do |
| // not extract events. |
| var hasListener = false; |
| var ON_SELECT_KEY = keyOf({ onSelect: null }); |
| |
| /** |
| * Get an object which is a unique representation of the current selection. |
| * |
| * The return value will not be consistent across nodes or browsers, but |
| * two identical selections on the same node will return identical objects. |
| * |
| * @param {DOMElement} node |
| * @return {object} |
| */ |
| function getSelection(node) { |
| if ('selectionStart' in node && ReactInputSelection.hasSelectionCapabilities(node)) { |
| return { |
| start: node.selectionStart, |
| end: node.selectionEnd |
| }; |
| } else if (window.getSelection) { |
| var selection = window.getSelection(); |
| return { |
| anchorNode: selection.anchorNode, |
| anchorOffset: selection.anchorOffset, |
| focusNode: selection.focusNode, |
| focusOffset: selection.focusOffset |
| }; |
| } else if (document.selection) { |
| var range = document.selection.createRange(); |
| return { |
| parentElement: range.parentElement(), |
| text: range.text, |
| top: range.boundingTop, |
| left: range.boundingLeft |
| }; |
| } |
| } |
| |
| /** |
| * Poll selection to see whether it's changed. |
| * |
| * @param {object} nativeEvent |
| * @return {?SyntheticEvent} |
| */ |
| function constructSelectEvent(nativeEvent, nativeEventTarget) { |
| // Ensure we have the right element, and that the user is not dragging a |
| // selection (this matches native `select` event behavior). In HTML5, select |
| // fires only on input and textarea thus if there's no focused element we |
| // won't dispatch. |
| if (mouseDown || activeElement == null || activeElement !== getActiveElement()) { |
| return null; |
| } |
| |
| // Only fire when selection has actually changed. |
| var currentSelection = getSelection(activeElement); |
| if (!lastSelection || !shallowEqual(lastSelection, currentSelection)) { |
| lastSelection = currentSelection; |
| |
| var syntheticEvent = SyntheticEvent.getPooled(eventTypes.select, activeElementID, nativeEvent, nativeEventTarget); |
| |
| syntheticEvent.type = 'select'; |
| syntheticEvent.target = activeElement; |
| |
| EventPropagators.accumulateTwoPhaseDispatches(syntheticEvent); |
| |
| return syntheticEvent; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * This plugin creates an `onSelect` event that normalizes select events |
| * across form elements. |
| * |
| * Supported elements are: |
| * - input (see `isTextInputElement`) |
| * - textarea |
| * - contentEditable |
| * |
| * This differs from native browser implementations in the following ways: |
| * - Fires on contentEditable fields as well as inputs. |
| * - Fires for collapsed selection. |
| * - Fires after user input. |
| */ |
| var SelectEventPlugin = { |
| |
| eventTypes: eventTypes, |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @see {EventPluginHub.extractEvents} |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| if (!hasListener) { |
| return null; |
| } |
| |
| switch (topLevelType) { |
| // Track the input node that has focus. |
| case topLevelTypes.topFocus: |
| if (isTextInputElement(topLevelTarget) || topLevelTarget.contentEditable === 'true') { |
| activeElement = topLevelTarget; |
| activeElementID = topLevelTargetID; |
| lastSelection = null; |
| } |
| break; |
| case topLevelTypes.topBlur: |
| activeElement = null; |
| activeElementID = null; |
| lastSelection = null; |
| break; |
| |
| // Don't fire the event while the user is dragging. This matches the |
| // semantics of the native select event. |
| case topLevelTypes.topMouseDown: |
| mouseDown = true; |
| break; |
| case topLevelTypes.topContextMenu: |
| case topLevelTypes.topMouseUp: |
| mouseDown = false; |
| return constructSelectEvent(nativeEvent, nativeEventTarget); |
| |
| // Chrome and IE fire non-standard event when selection is changed (and |
| // sometimes when it hasn't). IE's event fires out of order with respect |
| // to key and input events on deletion, so we discard it. |
| // |
| // Firefox doesn't support selectionchange, so check selection status |
| // after each key entry. The selection changes after keydown and before |
| // keyup, but we check on keydown as well in the case of holding down a |
| // key, when multiple keydown events are fired but only one keyup is. |
| // This is also our approach for IE handling, for the reason above. |
| case topLevelTypes.topSelectionChange: |
| if (skipSelectionChangeEvent) { |
| break; |
| } |
| // falls through |
| case topLevelTypes.topKeyDown: |
| case topLevelTypes.topKeyUp: |
| return constructSelectEvent(nativeEvent, nativeEventTarget); |
| } |
| |
| return null; |
| }, |
| |
| didPutListener: function (id, registrationName, listener) { |
| if (registrationName === ON_SELECT_KEY) { |
| hasListener = true; |
| } |
| } |
| }; |
| |
| module.exports = SelectEventPlugin; |
| },{"105":105,"134":134,"147":147,"15":15,"156":156,"166":166,"171":171,"19":19,"66":66}],100:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ServerReactRootIndex |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Size of the reactRoot ID space. We generate random numbers for React root |
| * IDs and if there's a collision the events and DOM update system will |
| * get confused. In the future we need a way to generate GUIDs but for |
| * now this will work on a smaller scale. |
| */ |
| var GLOBAL_MOUNT_POINT_MAX = Math.pow(2, 53); |
| |
| var ServerReactRootIndex = { |
| createReactRootIndex: function () { |
| return Math.ceil(Math.random() * GLOBAL_MOUNT_POINT_MAX); |
| } |
| }; |
| |
| module.exports = ServerReactRootIndex; |
| },{}],101:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SimpleEventPlugin |
| */ |
| |
| 'use strict'; |
| |
| var EventConstants = _dereq_(15); |
| var EventListener = _dereq_(146); |
| var EventPropagators = _dereq_(19); |
| var ReactMount = _dereq_(72); |
| var SyntheticClipboardEvent = _dereq_(102); |
| var SyntheticEvent = _dereq_(105); |
| var SyntheticFocusEvent = _dereq_(106); |
| var SyntheticKeyboardEvent = _dereq_(108); |
| var SyntheticMouseEvent = _dereq_(109); |
| var SyntheticDragEvent = _dereq_(104); |
| var SyntheticTouchEvent = _dereq_(110); |
| var SyntheticUIEvent = _dereq_(111); |
| var SyntheticWheelEvent = _dereq_(112); |
| |
| var emptyFunction = _dereq_(153); |
| var getEventCharCode = _dereq_(125); |
| var invariant = _dereq_(161); |
| var keyOf = _dereq_(166); |
| |
| var topLevelTypes = EventConstants.topLevelTypes; |
| |
| var eventTypes = { |
| abort: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onAbort: true }), |
| captured: keyOf({ onAbortCapture: true }) |
| } |
| }, |
| blur: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onBlur: true }), |
| captured: keyOf({ onBlurCapture: true }) |
| } |
| }, |
| canPlay: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCanPlay: true }), |
| captured: keyOf({ onCanPlayCapture: true }) |
| } |
| }, |
| canPlayThrough: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCanPlayThrough: true }), |
| captured: keyOf({ onCanPlayThroughCapture: true }) |
| } |
| }, |
| click: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onClick: true }), |
| captured: keyOf({ onClickCapture: true }) |
| } |
| }, |
| contextMenu: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onContextMenu: true }), |
| captured: keyOf({ onContextMenuCapture: true }) |
| } |
| }, |
| copy: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCopy: true }), |
| captured: keyOf({ onCopyCapture: true }) |
| } |
| }, |
| cut: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onCut: true }), |
| captured: keyOf({ onCutCapture: true }) |
| } |
| }, |
| doubleClick: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDoubleClick: true }), |
| captured: keyOf({ onDoubleClickCapture: true }) |
| } |
| }, |
| drag: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDrag: true }), |
| captured: keyOf({ onDragCapture: true }) |
| } |
| }, |
| dragEnd: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragEnd: true }), |
| captured: keyOf({ onDragEndCapture: true }) |
| } |
| }, |
| dragEnter: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragEnter: true }), |
| captured: keyOf({ onDragEnterCapture: true }) |
| } |
| }, |
| dragExit: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragExit: true }), |
| captured: keyOf({ onDragExitCapture: true }) |
| } |
| }, |
| dragLeave: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragLeave: true }), |
| captured: keyOf({ onDragLeaveCapture: true }) |
| } |
| }, |
| dragOver: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragOver: true }), |
| captured: keyOf({ onDragOverCapture: true }) |
| } |
| }, |
| dragStart: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDragStart: true }), |
| captured: keyOf({ onDragStartCapture: true }) |
| } |
| }, |
| drop: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDrop: true }), |
| captured: keyOf({ onDropCapture: true }) |
| } |
| }, |
| durationChange: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onDurationChange: true }), |
| captured: keyOf({ onDurationChangeCapture: true }) |
| } |
| }, |
| emptied: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onEmptied: true }), |
| captured: keyOf({ onEmptiedCapture: true }) |
| } |
| }, |
| encrypted: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onEncrypted: true }), |
| captured: keyOf({ onEncryptedCapture: true }) |
| } |
| }, |
| ended: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onEnded: true }), |
| captured: keyOf({ onEndedCapture: true }) |
| } |
| }, |
| error: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onError: true }), |
| captured: keyOf({ onErrorCapture: true }) |
| } |
| }, |
| focus: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onFocus: true }), |
| captured: keyOf({ onFocusCapture: true }) |
| } |
| }, |
| input: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onInput: true }), |
| captured: keyOf({ onInputCapture: true }) |
| } |
| }, |
| keyDown: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onKeyDown: true }), |
| captured: keyOf({ onKeyDownCapture: true }) |
| } |
| }, |
| keyPress: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onKeyPress: true }), |
| captured: keyOf({ onKeyPressCapture: true }) |
| } |
| }, |
| keyUp: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onKeyUp: true }), |
| captured: keyOf({ onKeyUpCapture: true }) |
| } |
| }, |
| load: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onLoad: true }), |
| captured: keyOf({ onLoadCapture: true }) |
| } |
| }, |
| loadedData: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onLoadedData: true }), |
| captured: keyOf({ onLoadedDataCapture: true }) |
| } |
| }, |
| loadedMetadata: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onLoadedMetadata: true }), |
| captured: keyOf({ onLoadedMetadataCapture: true }) |
| } |
| }, |
| loadStart: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onLoadStart: true }), |
| captured: keyOf({ onLoadStartCapture: true }) |
| } |
| }, |
| // Note: We do not allow listening to mouseOver events. Instead, use the |
| // onMouseEnter/onMouseLeave created by `EnterLeaveEventPlugin`. |
| mouseDown: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onMouseDown: true }), |
| captured: keyOf({ onMouseDownCapture: true }) |
| } |
| }, |
| mouseMove: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onMouseMove: true }), |
| captured: keyOf({ onMouseMoveCapture: true }) |
| } |
| }, |
| mouseOut: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onMouseOut: true }), |
| captured: keyOf({ onMouseOutCapture: true }) |
| } |
| }, |
| mouseOver: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onMouseOver: true }), |
| captured: keyOf({ onMouseOverCapture: true }) |
| } |
| }, |
| mouseUp: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onMouseUp: true }), |
| captured: keyOf({ onMouseUpCapture: true }) |
| } |
| }, |
| paste: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onPaste: true }), |
| captured: keyOf({ onPasteCapture: true }) |
| } |
| }, |
| pause: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onPause: true }), |
| captured: keyOf({ onPauseCapture: true }) |
| } |
| }, |
| play: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onPlay: true }), |
| captured: keyOf({ onPlayCapture: true }) |
| } |
| }, |
| playing: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onPlaying: true }), |
| captured: keyOf({ onPlayingCapture: true }) |
| } |
| }, |
| progress: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onProgress: true }), |
| captured: keyOf({ onProgressCapture: true }) |
| } |
| }, |
| rateChange: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onRateChange: true }), |
| captured: keyOf({ onRateChangeCapture: true }) |
| } |
| }, |
| reset: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onReset: true }), |
| captured: keyOf({ onResetCapture: true }) |
| } |
| }, |
| scroll: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onScroll: true }), |
| captured: keyOf({ onScrollCapture: true }) |
| } |
| }, |
| seeked: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onSeeked: true }), |
| captured: keyOf({ onSeekedCapture: true }) |
| } |
| }, |
| seeking: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onSeeking: true }), |
| captured: keyOf({ onSeekingCapture: true }) |
| } |
| }, |
| stalled: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onStalled: true }), |
| captured: keyOf({ onStalledCapture: true }) |
| } |
| }, |
| submit: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onSubmit: true }), |
| captured: keyOf({ onSubmitCapture: true }) |
| } |
| }, |
| suspend: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onSuspend: true }), |
| captured: keyOf({ onSuspendCapture: true }) |
| } |
| }, |
| timeUpdate: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onTimeUpdate: true }), |
| captured: keyOf({ onTimeUpdateCapture: true }) |
| } |
| }, |
| touchCancel: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onTouchCancel: true }), |
| captured: keyOf({ onTouchCancelCapture: true }) |
| } |
| }, |
| touchEnd: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onTouchEnd: true }), |
| captured: keyOf({ onTouchEndCapture: true }) |
| } |
| }, |
| touchMove: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onTouchMove: true }), |
| captured: keyOf({ onTouchMoveCapture: true }) |
| } |
| }, |
| touchStart: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onTouchStart: true }), |
| captured: keyOf({ onTouchStartCapture: true }) |
| } |
| }, |
| volumeChange: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onVolumeChange: true }), |
| captured: keyOf({ onVolumeChangeCapture: true }) |
| } |
| }, |
| waiting: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onWaiting: true }), |
| captured: keyOf({ onWaitingCapture: true }) |
| } |
| }, |
| wheel: { |
| phasedRegistrationNames: { |
| bubbled: keyOf({ onWheel: true }), |
| captured: keyOf({ onWheelCapture: true }) |
| } |
| } |
| }; |
| |
| var topLevelEventsToDispatchConfig = { |
| topAbort: eventTypes.abort, |
| topBlur: eventTypes.blur, |
| topCanPlay: eventTypes.canPlay, |
| topCanPlayThrough: eventTypes.canPlayThrough, |
| topClick: eventTypes.click, |
| topContextMenu: eventTypes.contextMenu, |
| topCopy: eventTypes.copy, |
| topCut: eventTypes.cut, |
| topDoubleClick: eventTypes.doubleClick, |
| topDrag: eventTypes.drag, |
| topDragEnd: eventTypes.dragEnd, |
| topDragEnter: eventTypes.dragEnter, |
| topDragExit: eventTypes.dragExit, |
| topDragLeave: eventTypes.dragLeave, |
| topDragOver: eventTypes.dragOver, |
| topDragStart: eventTypes.dragStart, |
| topDrop: eventTypes.drop, |
| topDurationChange: eventTypes.durationChange, |
| topEmptied: eventTypes.emptied, |
| topEncrypted: eventTypes.encrypted, |
| topEnded: eventTypes.ended, |
| topError: eventTypes.error, |
| topFocus: eventTypes.focus, |
| topInput: eventTypes.input, |
| topKeyDown: eventTypes.keyDown, |
| topKeyPress: eventTypes.keyPress, |
| topKeyUp: eventTypes.keyUp, |
| topLoad: eventTypes.load, |
| topLoadedData: eventTypes.loadedData, |
| topLoadedMetadata: eventTypes.loadedMetadata, |
| topLoadStart: eventTypes.loadStart, |
| topMouseDown: eventTypes.mouseDown, |
| topMouseMove: eventTypes.mouseMove, |
| topMouseOut: eventTypes.mouseOut, |
| topMouseOver: eventTypes.mouseOver, |
| topMouseUp: eventTypes.mouseUp, |
| topPaste: eventTypes.paste, |
| topPause: eventTypes.pause, |
| topPlay: eventTypes.play, |
| topPlaying: eventTypes.playing, |
| topProgress: eventTypes.progress, |
| topRateChange: eventTypes.rateChange, |
| topReset: eventTypes.reset, |
| topScroll: eventTypes.scroll, |
| topSeeked: eventTypes.seeked, |
| topSeeking: eventTypes.seeking, |
| topStalled: eventTypes.stalled, |
| topSubmit: eventTypes.submit, |
| topSuspend: eventTypes.suspend, |
| topTimeUpdate: eventTypes.timeUpdate, |
| topTouchCancel: eventTypes.touchCancel, |
| topTouchEnd: eventTypes.touchEnd, |
| topTouchMove: eventTypes.touchMove, |
| topTouchStart: eventTypes.touchStart, |
| topVolumeChange: eventTypes.volumeChange, |
| topWaiting: eventTypes.waiting, |
| topWheel: eventTypes.wheel |
| }; |
| |
| for (var type in topLevelEventsToDispatchConfig) { |
| topLevelEventsToDispatchConfig[type].dependencies = [type]; |
| } |
| |
| var ON_CLICK_KEY = keyOf({ onClick: null }); |
| var onClickListeners = {}; |
| |
| var SimpleEventPlugin = { |
| |
| eventTypes: eventTypes, |
| |
| /** |
| * @param {string} topLevelType Record from `EventConstants`. |
| * @param {DOMEventTarget} topLevelTarget The listening component root node. |
| * @param {string} topLevelTargetID ID of `topLevelTarget`. |
| * @param {object} nativeEvent Native browser event. |
| * @return {*} An accumulation of synthetic events. |
| * @see {EventPluginHub.extractEvents} |
| */ |
| extractEvents: function (topLevelType, topLevelTarget, topLevelTargetID, nativeEvent, nativeEventTarget) { |
| var dispatchConfig = topLevelEventsToDispatchConfig[topLevelType]; |
| if (!dispatchConfig) { |
| return null; |
| } |
| var EventConstructor; |
| switch (topLevelType) { |
| case topLevelTypes.topAbort: |
| case topLevelTypes.topCanPlay: |
| case topLevelTypes.topCanPlayThrough: |
| case topLevelTypes.topDurationChange: |
| case topLevelTypes.topEmptied: |
| case topLevelTypes.topEncrypted: |
| case topLevelTypes.topEnded: |
| case topLevelTypes.topError: |
| case topLevelTypes.topInput: |
| case topLevelTypes.topLoad: |
| case topLevelTypes.topLoadedData: |
| case topLevelTypes.topLoadedMetadata: |
| case topLevelTypes.topLoadStart: |
| case topLevelTypes.topPause: |
| case topLevelTypes.topPlay: |
| case topLevelTypes.topPlaying: |
| case topLevelTypes.topProgress: |
| case topLevelTypes.topRateChange: |
| case topLevelTypes.topReset: |
| case topLevelTypes.topSeeked: |
| case topLevelTypes.topSeeking: |
| case topLevelTypes.topStalled: |
| case topLevelTypes.topSubmit: |
| case topLevelTypes.topSuspend: |
| case topLevelTypes.topTimeUpdate: |
| case topLevelTypes.topVolumeChange: |
| case topLevelTypes.topWaiting: |
| // HTML Events |
| // @see http://www.w3.org/TR/html5/index.html#events-0 |
| EventConstructor = SyntheticEvent; |
| break; |
| case topLevelTypes.topKeyPress: |
| // FireFox creates a keypress event for function keys too. This removes |
| // the unwanted keypress events. Enter is however both printable and |
| // non-printable. One would expect Tab to be as well (but it isn't). |
| if (getEventCharCode(nativeEvent) === 0) { |
| return null; |
| } |
| /* falls through */ |
| case topLevelTypes.topKeyDown: |
| case topLevelTypes.topKeyUp: |
| EventConstructor = SyntheticKeyboardEvent; |
| break; |
| case topLevelTypes.topBlur: |
| case topLevelTypes.topFocus: |
| EventConstructor = SyntheticFocusEvent; |
| break; |
| case topLevelTypes.topClick: |
| // Firefox creates a click event on right mouse clicks. This removes the |
| // unwanted click events. |
| if (nativeEvent.button === 2) { |
| return null; |
| } |
| /* falls through */ |
| case topLevelTypes.topContextMenu: |
| case topLevelTypes.topDoubleClick: |
| case topLevelTypes.topMouseDown: |
| case topLevelTypes.topMouseMove: |
| case topLevelTypes.topMouseOut: |
| case topLevelTypes.topMouseOver: |
| case topLevelTypes.topMouseUp: |
| EventConstructor = SyntheticMouseEvent; |
| break; |
| case topLevelTypes.topDrag: |
| case topLevelTypes.topDragEnd: |
| case topLevelTypes.topDragEnter: |
| case topLevelTypes.topDragExit: |
| case topLevelTypes.topDragLeave: |
| case topLevelTypes.topDragOver: |
| case topLevelTypes.topDragStart: |
| case topLevelTypes.topDrop: |
| EventConstructor = SyntheticDragEvent; |
| break; |
| case topLevelTypes.topTouchCancel: |
| case topLevelTypes.topTouchEnd: |
| case topLevelTypes.topTouchMove: |
| case topLevelTypes.topTouchStart: |
| EventConstructor = SyntheticTouchEvent; |
| break; |
| case topLevelTypes.topScroll: |
| EventConstructor = SyntheticUIEvent; |
| break; |
| case topLevelTypes.topWheel: |
| EventConstructor = SyntheticWheelEvent; |
| break; |
| case topLevelTypes.topCopy: |
| case topLevelTypes.topCut: |
| case topLevelTypes.topPaste: |
| EventConstructor = SyntheticClipboardEvent; |
| break; |
| } |
| !EventConstructor ? "development" !== 'production' ? invariant(false, 'SimpleEventPlugin: Unhandled event type, `%s`.', topLevelType) : invariant(false) : undefined; |
| var event = EventConstructor.getPooled(dispatchConfig, topLevelTargetID, nativeEvent, nativeEventTarget); |
| EventPropagators.accumulateTwoPhaseDispatches(event); |
| return event; |
| }, |
| |
| didPutListener: function (id, registrationName, listener) { |
| // Mobile Safari does not fire properly bubble click events on |
| // non-interactive elements, which means delegated click listeners do not |
| // fire. The workaround for this bug involves attaching an empty click |
| // listener on the target node. |
| if (registrationName === ON_CLICK_KEY) { |
| var node = ReactMount.getNode(id); |
| if (!onClickListeners[id]) { |
| onClickListeners[id] = EventListener.listen(node, 'click', emptyFunction); |
| } |
| } |
| }, |
| |
| willDeleteListener: function (id, registrationName) { |
| if (registrationName === ON_CLICK_KEY) { |
| onClickListeners[id].remove(); |
| delete onClickListeners[id]; |
| } |
| } |
| |
| }; |
| |
| module.exports = SimpleEventPlugin; |
| },{"102":102,"104":104,"105":105,"106":106,"108":108,"109":109,"110":110,"111":111,"112":112,"125":125,"146":146,"15":15,"153":153,"161":161,"166":166,"19":19,"72":72}],102:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticClipboardEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticEvent = _dereq_(105); |
| |
| /** |
| * @interface Event |
| * @see http://www.w3.org/TR/clipboard-apis/ |
| */ |
| var ClipboardEventInterface = { |
| clipboardData: function (event) { |
| return 'clipboardData' in event ? event.clipboardData : window.clipboardData; |
| } |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticClipboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticEvent.augmentClass(SyntheticClipboardEvent, ClipboardEventInterface); |
| |
| module.exports = SyntheticClipboardEvent; |
| },{"105":105}],103:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticCompositionEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticEvent = _dereq_(105); |
| |
| /** |
| * @interface Event |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/#events-compositionevents |
| */ |
| var CompositionEventInterface = { |
| data: null |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticCompositionEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticEvent.augmentClass(SyntheticCompositionEvent, CompositionEventInterface); |
| |
| module.exports = SyntheticCompositionEvent; |
| },{"105":105}],104:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticDragEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticMouseEvent = _dereq_(109); |
| |
| /** |
| * @interface DragEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var DragEventInterface = { |
| dataTransfer: null |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticDragEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticMouseEvent.augmentClass(SyntheticDragEvent, DragEventInterface); |
| |
| module.exports = SyntheticDragEvent; |
| },{"109":109}],105:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var PooledClass = _dereq_(25); |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| var warning = _dereq_(173); |
| |
| /** |
| * @interface Event |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var EventInterface = { |
| type: null, |
| // currentTarget is set when dispatching; no use in copying it here |
| currentTarget: emptyFunction.thatReturnsNull, |
| eventPhase: null, |
| bubbles: null, |
| cancelable: null, |
| timeStamp: function (event) { |
| return event.timeStamp || Date.now(); |
| }, |
| defaultPrevented: null, |
| isTrusted: null |
| }; |
| |
| /** |
| * 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 {string} dispatchMarker Marker identifying the event target. |
| * @param {object} nativeEvent Native browser event. |
| */ |
| function SyntheticEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| this.dispatchConfig = dispatchConfig; |
| this.dispatchMarker = dispatchMarker; |
| this.nativeEvent = nativeEvent; |
| this.target = nativeEventTarget; |
| this.currentTarget = nativeEventTarget; |
| |
| var Interface = this.constructor.Interface; |
| for (var propName in Interface) { |
| if (!Interface.hasOwnProperty(propName)) { |
| continue; |
| } |
| var normalize = Interface[propName]; |
| if (normalize) { |
| this[propName] = normalize(nativeEvent); |
| } 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; |
| } |
| |
| assign(SyntheticEvent.prototype, { |
| |
| preventDefault: function () { |
| this.defaultPrevented = true; |
| var event = this.nativeEvent; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(event, 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re calling `preventDefault` on a ' + 'released/nullified synthetic event. This is a no-op. See ' + 'https://fb.me/react-event-pooling for more information.') : undefined; |
| } |
| if (!event) { |
| return; |
| } |
| |
| if (event.preventDefault) { |
| event.preventDefault(); |
| } else { |
| event.returnValue = false; |
| } |
| this.isDefaultPrevented = emptyFunction.thatReturnsTrue; |
| }, |
| |
| stopPropagation: function () { |
| var event = this.nativeEvent; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(event, 'This synthetic event is reused for performance reasons. If you\'re ' + 'seeing this, you\'re calling `stopPropagation` on a ' + 'released/nullified synthetic event. This is a no-op. See ' + 'https://fb.me/react-event-pooling for more information.') : undefined; |
| } |
| if (!event) { |
| return; |
| } |
| |
| if (event.stopPropagation) { |
| event.stopPropagation(); |
| } else { |
| event.cancelBubble = true; |
| } |
| this.isPropagationStopped = emptyFunction.thatReturnsTrue; |
| }, |
| |
| /** |
| * We release all dispatched `SyntheticEvent`s after each event loop, adding |
| * them back into the pool. This allows a way to hold onto a reference that |
| * won't be added back into the pool. |
| */ |
| persist: function () { |
| this.isPersistent = emptyFunction.thatReturnsTrue; |
| }, |
| |
| /** |
| * Checks if this event should be released back into the pool. |
| * |
| * @return {boolean} True if this should not be released, false otherwise. |
| */ |
| isPersistent: emptyFunction.thatReturnsFalse, |
| |
| /** |
| * `PooledClass` looks for `destructor` on each instance it releases. |
| */ |
| destructor: function () { |
| var Interface = this.constructor.Interface; |
| for (var propName in Interface) { |
| this[propName] = null; |
| } |
| this.dispatchConfig = null; |
| this.dispatchMarker = null; |
| this.nativeEvent = null; |
| } |
| |
| }); |
| |
| SyntheticEvent.Interface = EventInterface; |
| |
| /** |
| * Helper to reduce boilerplate when creating subclasses. |
| * |
| * @param {function} Class |
| * @param {?object} Interface |
| */ |
| SyntheticEvent.augmentClass = function (Class, Interface) { |
| var Super = this; |
| |
| var prototype = Object.create(Super.prototype); |
| assign(prototype, Class.prototype); |
| Class.prototype = prototype; |
| Class.prototype.constructor = Class; |
| |
| Class.Interface = assign({}, Super.Interface, Interface); |
| Class.augmentClass = Super.augmentClass; |
| |
| PooledClass.addPoolingTo(Class, PooledClass.fourArgumentPooler); |
| }; |
| |
| PooledClass.addPoolingTo(SyntheticEvent, PooledClass.fourArgumentPooler); |
| |
| module.exports = SyntheticEvent; |
| },{"153":153,"173":173,"24":24,"25":25}],106:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticFocusEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticUIEvent = _dereq_(111); |
| |
| /** |
| * @interface FocusEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var FocusEventInterface = { |
| relatedTarget: null |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticFocusEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticUIEvent.augmentClass(SyntheticFocusEvent, FocusEventInterface); |
| |
| module.exports = SyntheticFocusEvent; |
| },{"111":111}],107:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticInputEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticEvent = _dereq_(105); |
| |
| /** |
| * @interface Event |
| * @see http://www.w3.org/TR/2013/WD-DOM-Level-3-Events-20131105 |
| * /#events-inputevents |
| */ |
| var InputEventInterface = { |
| data: null |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticInputEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticEvent.augmentClass(SyntheticInputEvent, InputEventInterface); |
| |
| module.exports = SyntheticInputEvent; |
| },{"105":105}],108:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticKeyboardEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticUIEvent = _dereq_(111); |
| |
| var getEventCharCode = _dereq_(125); |
| var getEventKey = _dereq_(126); |
| var getEventModifierState = _dereq_(127); |
| |
| /** |
| * @interface KeyboardEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var KeyboardEventInterface = { |
| key: getEventKey, |
| location: null, |
| ctrlKey: null, |
| shiftKey: null, |
| altKey: null, |
| metaKey: null, |
| repeat: null, |
| locale: null, |
| getModifierState: getEventModifierState, |
| // Legacy Interface |
| charCode: function (event) { |
| // `charCode` is the result of a KeyPress event and represents the value of |
| // the actual printable character. |
| |
| // KeyPress is deprecated, but its replacement is not yet final and not |
| // implemented in any major browser. Only KeyPress has charCode. |
| if (event.type === 'keypress') { |
| return getEventCharCode(event); |
| } |
| return 0; |
| }, |
| keyCode: function (event) { |
| // `keyCode` is the result of a KeyDown/Up event and represents the value of |
| // physical keyboard key. |
| |
| // The actual meaning of the value depends on the users' keyboard layout |
| // which cannot be detected. Assuming that it is a US keyboard layout |
| // provides a surprisingly accurate mapping for US and European users. |
| // Due to this, it is left to the user to implement at this time. |
| if (event.type === 'keydown' || event.type === 'keyup') { |
| return event.keyCode; |
| } |
| return 0; |
| }, |
| which: function (event) { |
| // `which` is an alias for either `keyCode` or `charCode` depending on the |
| // type of the event. |
| if (event.type === 'keypress') { |
| return getEventCharCode(event); |
| } |
| if (event.type === 'keydown' || event.type === 'keyup') { |
| return event.keyCode; |
| } |
| return 0; |
| } |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticKeyboardEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticUIEvent.augmentClass(SyntheticKeyboardEvent, KeyboardEventInterface); |
| |
| module.exports = SyntheticKeyboardEvent; |
| },{"111":111,"125":125,"126":126,"127":127}],109:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticMouseEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticUIEvent = _dereq_(111); |
| var ViewportMetrics = _dereq_(114); |
| |
| var getEventModifierState = _dereq_(127); |
| |
| /** |
| * @interface MouseEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var MouseEventInterface = { |
| screenX: null, |
| screenY: null, |
| clientX: null, |
| clientY: null, |
| ctrlKey: null, |
| shiftKey: null, |
| altKey: null, |
| metaKey: null, |
| getModifierState: getEventModifierState, |
| button: function (event) { |
| // Webkit, Firefox, IE9+ |
| // which: 1 2 3 |
| // button: 0 1 2 (standard) |
| var button = event.button; |
| if ('which' in event) { |
| return button; |
| } |
| // IE<9 |
| // which: undefined |
| // button: 0 0 0 |
| // button: 1 4 2 (onmouseup) |
| return button === 2 ? 2 : button === 4 ? 1 : 0; |
| }, |
| buttons: null, |
| relatedTarget: function (event) { |
| return event.relatedTarget || (event.fromElement === event.srcElement ? event.toElement : event.fromElement); |
| }, |
| // "Proprietary" Interface. |
| pageX: function (event) { |
| return 'pageX' in event ? event.pageX : event.clientX + ViewportMetrics.currentScrollLeft; |
| }, |
| pageY: function (event) { |
| return 'pageY' in event ? event.pageY : event.clientY + ViewportMetrics.currentScrollTop; |
| } |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticMouseEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticUIEvent.augmentClass(SyntheticMouseEvent, MouseEventInterface); |
| |
| module.exports = SyntheticMouseEvent; |
| },{"111":111,"114":114,"127":127}],110:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticTouchEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticUIEvent = _dereq_(111); |
| |
| var getEventModifierState = _dereq_(127); |
| |
| /** |
| * @interface TouchEvent |
| * @see http://www.w3.org/TR/touch-events/ |
| */ |
| var TouchEventInterface = { |
| touches: null, |
| targetTouches: null, |
| changedTouches: null, |
| altKey: null, |
| metaKey: null, |
| ctrlKey: null, |
| shiftKey: null, |
| getModifierState: getEventModifierState |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticTouchEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticUIEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticUIEvent.augmentClass(SyntheticTouchEvent, TouchEventInterface); |
| |
| module.exports = SyntheticTouchEvent; |
| },{"111":111,"127":127}],111:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticUIEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticEvent = _dereq_(105); |
| |
| var getEventTarget = _dereq_(128); |
| |
| /** |
| * @interface UIEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var UIEventInterface = { |
| view: function (event) { |
| if (event.view) { |
| return event.view; |
| } |
| |
| var target = getEventTarget(event); |
| if (target != null && target.window === target) { |
| // target is a window object |
| return target; |
| } |
| |
| var doc = target.ownerDocument; |
| // TODO: Figure out why `ownerDocument` is sometimes undefined in IE8. |
| if (doc) { |
| return doc.defaultView || doc.parentWindow; |
| } else { |
| return window; |
| } |
| }, |
| detail: function (event) { |
| return event.detail || 0; |
| } |
| }; |
| |
| /** |
| * @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} |
| */ |
| function SyntheticUIEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticEvent.augmentClass(SyntheticUIEvent, UIEventInterface); |
| |
| module.exports = SyntheticUIEvent; |
| },{"105":105,"128":128}],112:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule SyntheticWheelEvent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var SyntheticMouseEvent = _dereq_(109); |
| |
| /** |
| * @interface WheelEvent |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/ |
| */ |
| var WheelEventInterface = { |
| deltaX: function (event) { |
| return 'deltaX' in event ? event.deltaX : |
| // Fallback to `wheelDeltaX` for Webkit and normalize (right is positive). |
| 'wheelDeltaX' in event ? -event.wheelDeltaX : 0; |
| }, |
| deltaY: function (event) { |
| return 'deltaY' in event ? event.deltaY : |
| // Fallback to `wheelDeltaY` for Webkit and normalize (down is positive). |
| 'wheelDeltaY' in event ? -event.wheelDeltaY : |
| // Fallback to `wheelDelta` for IE<9 and normalize (down is positive). |
| 'wheelDelta' in event ? -event.wheelDelta : 0; |
| }, |
| deltaZ: null, |
| |
| // Browsers without "deltaMode" is reporting in raw wheel delta where one |
| // notch on the scroll is always +/- 120, roughly equivalent to pixels. |
| // A good approximation of DOM_DELTA_LINE (1) is 5% of viewport size or |
| // ~40 pixels, for DOM_DELTA_SCREEN (2) it is 87.5% of viewport size. |
| deltaMode: null |
| }; |
| |
| /** |
| * @param {object} dispatchConfig Configuration used to dispatch this event. |
| * @param {string} dispatchMarker Marker identifying the event target. |
| * @param {object} nativeEvent Native browser event. |
| * @extends {SyntheticMouseEvent} |
| */ |
| function SyntheticWheelEvent(dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget) { |
| SyntheticMouseEvent.call(this, dispatchConfig, dispatchMarker, nativeEvent, nativeEventTarget); |
| } |
| |
| SyntheticMouseEvent.augmentClass(SyntheticWheelEvent, WheelEventInterface); |
| |
| module.exports = SyntheticWheelEvent; |
| },{"109":109}],113:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule Transaction |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * `Transaction` creates a black box that is able to wrap any method such that |
| * certain invariants are maintained before and after the method is invoked |
| * (Even if an exception is thrown while invoking the wrapped method). Whoever |
| * instantiates a transaction can provide enforcers of the invariants at |
| * creation time. The `Transaction` class itself will supply one additional |
| * automatic invariant for you - the invariant that any transaction instance |
| * should not be run while it is already being run. You would typically create a |
| * single instance of a `Transaction` for reuse multiple times, that potentially |
| * is used to wrap several different methods. Wrappers are extremely simple - |
| * they only require implementing two methods. |
| * |
| * <pre> |
| * wrappers (injected at creation time) |
| * + + |
| * | | |
| * +-----------------|--------|--------------+ |
| * | v | | |
| * | +---------------+ | | |
| * | +--| wrapper1 |---|----+ | |
| * | | +---------------+ v | | |
| * | | +-------------+ | | |
| * | | +----| wrapper2 |--------+ | |
| * | | | +-------------+ | | | |
| * | | | | | | |
| * | v v v v | wrapper |
| * | +---+ +---+ +---------+ +---+ +---+ | invariants |
| * perform(anyMethod) | | | | | | | | | | | | maintained |
| * +----------------->|-|---|-|---|-->|anyMethod|---|---|-|---|-|--------> |
| * | | | | | | | | | | | | |
| * | | | | | | | | | | | | |
| * | | | | | | | | | | | | |
| * | +---+ +---+ +---------+ +---+ +---+ | |
| * | initialize close | |
| * +-----------------------------------------+ |
| * </pre> |
| * |
| * Use cases: |
| * - Preserving the input selection ranges before/after reconciliation. |
| * Restoring selection even in the event of an unexpected error. |
| * - Deactivating events while rearranging the DOM, preventing blurs/focuses, |
| * while guaranteeing that afterwards, the event system is reactivated. |
| * - Flushing a queue of collected DOM mutations to the main UI thread after a |
| * reconciliation takes place in a worker thread. |
| * - Invoking any collected `componentDidUpdate` callbacks after rendering new |
| * content. |
| * - (Future use case): Wrapping particular flushes of the `ReactWorker` queue |
| * to preserve the `scrollTop` (an automatic scroll aware DOM). |
| * - (Future use case): Layout calculations before and after DOM updates. |
| * |
| * Transactional plugin API: |
| * - A module that has an `initialize` method that returns any precomputation. |
| * - and a `close` method that accepts the precomputation. `close` is invoked |
| * when the wrapped process is completed, or has failed. |
| * |
| * @param {Array<TransactionalWrapper>} transactionWrapper Wrapper modules |
| * that implement `initialize` and `close`. |
| * @return {Transaction} Single transaction for reuse in thread. |
| * |
| * @class Transaction |
| */ |
| var Mixin = { |
| /** |
| * Sets up this instance so that it is prepared for collecting metrics. Does |
| * so such that this setup method may be used on an instance that is already |
| * initialized, in a way that does not consume additional memory upon reuse. |
| * That can be useful if you decide to make your subclass of this mixin a |
| * "PooledClass". |
| */ |
| reinitializeTransaction: function () { |
| this.transactionWrappers = this.getTransactionWrappers(); |
| if (this.wrapperInitData) { |
| this.wrapperInitData.length = 0; |
| } else { |
| this.wrapperInitData = []; |
| } |
| this._isInTransaction = false; |
| }, |
| |
| _isInTransaction: false, |
| |
| /** |
| * @abstract |
| * @return {Array<TransactionWrapper>} Array of transaction wrappers. |
| */ |
| getTransactionWrappers: null, |
| |
| isInTransaction: function () { |
| return !!this._isInTransaction; |
| }, |
| |
| /** |
| * Executes the function within a safety window. Use this for the top level |
| * methods that result in large amounts of computation/mutations that would |
| * need to be safety checked. The optional arguments helps prevent the need |
| * to bind in many cases. |
| * |
| * @param {function} method Member of scope to call. |
| * @param {Object} scope Scope to invoke from. |
| * @param {Object?=} a Argument to pass to the method. |
| * @param {Object?=} b Argument to pass to the method. |
| * @param {Object?=} c Argument to pass to the method. |
| * @param {Object?=} d Argument to pass to the method. |
| * @param {Object?=} e Argument to pass to the method. |
| * @param {Object?=} f Argument to pass to the method. |
| * |
| * @return {*} Return value from `method`. |
| */ |
| perform: function (method, scope, a, b, c, d, e, f) { |
| !!this.isInTransaction() ? "development" !== 'production' ? invariant(false, 'Transaction.perform(...): Cannot initialize a transaction when there ' + 'is already an outstanding transaction.') : invariant(false) : undefined; |
| var errorThrown; |
| var ret; |
| try { |
| this._isInTransaction = true; |
| // Catching errors makes debugging more difficult, so we start with |
| // errorThrown set to true before setting it to false after calling |
| // close -- if it's still set to true in the finally block, it means |
| // one of these calls threw. |
| errorThrown = true; |
| this.initializeAll(0); |
| ret = method.call(scope, a, b, c, d, e, f); |
| errorThrown = false; |
| } finally { |
| try { |
| if (errorThrown) { |
| // If `method` throws, prefer to show that stack trace over any thrown |
| // by invoking `closeAll`. |
| try { |
| this.closeAll(0); |
| } catch (err) {} |
| } else { |
| // Since `method` didn't throw, we don't want to silence the exception |
| // here. |
| this.closeAll(0); |
| } |
| } finally { |
| this._isInTransaction = false; |
| } |
| } |
| return ret; |
| }, |
| |
| initializeAll: function (startIndex) { |
| var transactionWrappers = this.transactionWrappers; |
| for (var i = startIndex; i < transactionWrappers.length; i++) { |
| var wrapper = transactionWrappers[i]; |
| try { |
| // Catching errors makes debugging more difficult, so we start with the |
| // OBSERVED_ERROR state before overwriting it with the real return value |
| // of initialize -- if it's still set to OBSERVED_ERROR in the finally |
| // block, it means wrapper.initialize threw. |
| this.wrapperInitData[i] = Transaction.OBSERVED_ERROR; |
| this.wrapperInitData[i] = wrapper.initialize ? wrapper.initialize.call(this) : null; |
| } finally { |
| if (this.wrapperInitData[i] === Transaction.OBSERVED_ERROR) { |
| // The initializer for wrapper i threw an error; initialize the |
| // remaining wrappers but silence any exceptions from them to ensure |
| // that the first error is the one to bubble up. |
| try { |
| this.initializeAll(i + 1); |
| } catch (err) {} |
| } |
| } |
| } |
| }, |
| |
| /** |
| * Invokes each of `this.transactionWrappers.close[i]` functions, passing into |
| * them the respective return values of `this.transactionWrappers.init[i]` |
| * (`close`rs that correspond to initializers that failed will not be |
| * invoked). |
| */ |
| closeAll: function (startIndex) { |
| !this.isInTransaction() ? "development" !== 'production' ? invariant(false, 'Transaction.closeAll(): Cannot close transaction when none are open.') : invariant(false) : undefined; |
| var transactionWrappers = this.transactionWrappers; |
| for (var i = startIndex; i < transactionWrappers.length; i++) { |
| var wrapper = transactionWrappers[i]; |
| var initData = this.wrapperInitData[i]; |
| var errorThrown; |
| try { |
| // Catching errors makes debugging more difficult, so we start with |
| // errorThrown set to true before setting it to false after calling |
| // close -- if it's still set to true in the finally block, it means |
| // wrapper.close threw. |
| errorThrown = true; |
| if (initData !== Transaction.OBSERVED_ERROR && wrapper.close) { |
| wrapper.close.call(this, initData); |
| } |
| errorThrown = false; |
| } finally { |
| if (errorThrown) { |
| // The closer for wrapper i threw an error; close the remaining |
| // wrappers but silence any exceptions from them to ensure that the |
| // first error is the one to bubble up. |
| try { |
| this.closeAll(i + 1); |
| } catch (e) {} |
| } |
| } |
| } |
| this.wrapperInitData.length = 0; |
| } |
| }; |
| |
| var Transaction = { |
| |
| Mixin: Mixin, |
| |
| /** |
| * Token to look for to determine if an error occurred. |
| */ |
| OBSERVED_ERROR: {} |
| |
| }; |
| |
| module.exports = Transaction; |
| },{"161":161}],114:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ViewportMetrics |
| */ |
| |
| 'use strict'; |
| |
| var ViewportMetrics = { |
| |
| currentScrollLeft: 0, |
| |
| currentScrollTop: 0, |
| |
| refreshScrollValues: function (scrollPosition) { |
| ViewportMetrics.currentScrollLeft = scrollPosition.x; |
| ViewportMetrics.currentScrollTop = scrollPosition.y; |
| } |
| |
| }; |
| |
| module.exports = ViewportMetrics; |
| },{}],115:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule accumulateInto |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * |
| * 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. |
| */ |
| |
| function accumulateInto(current, next) { |
| !(next != null) ? "development" !== 'production' ? invariant(false, 'accumulateInto(...): Accumulated items must not be null or undefined.') : invariant(false) : undefined; |
| 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). |
| var currentIsArray = Array.isArray(current); |
| var nextIsArray = Array.isArray(next); |
| |
| if (currentIsArray && nextIsArray) { |
| current.push.apply(current, next); |
| return current; |
| } |
| |
| if (currentIsArray) { |
| current.push(next); |
| return current; |
| } |
| |
| if (nextIsArray) { |
| // A bit too dangerous to mutate `next`. |
| return [current].concat(next); |
| } |
| |
| return [current, next]; |
| } |
| |
| module.exports = accumulateInto; |
| },{"161":161}],116:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule adler32 |
| */ |
| |
| 'use strict'; |
| |
| var MOD = 65521; |
| |
| // adler32 is not cryptographically strong, and is only used to sanity check that |
| // markup generated on the server matches the markup generated on the client. |
| // This implementation (a modified version of the SheetJS version) has been optimized |
| // for our use case, at the expense of conforming to the adler32 specification |
| // for non-ascii inputs. |
| function adler32(data) { |
| var a = 1; |
| var b = 0; |
| var i = 0; |
| var l = data.length; |
| var m = l & ~0x3; |
| while (i < m) { |
| for (; i < Math.min(i + 4096, m); i += 4) { |
| b += (a += data.charCodeAt(i)) + (a += data.charCodeAt(i + 1)) + (a += data.charCodeAt(i + 2)) + (a += data.charCodeAt(i + 3)); |
| } |
| a %= MOD; |
| b %= MOD; |
| } |
| for (; i < l; i++) { |
| b += a += data.charCodeAt(i); |
| } |
| a %= MOD; |
| b %= MOD; |
| return a | b << 16; |
| } |
| |
| module.exports = adler32; |
| },{}],117:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule canDefineProperty |
| */ |
| |
| 'use strict'; |
| |
| var canDefineProperty = false; |
| if ("development" !== 'production') { |
| try { |
| Object.defineProperty({}, 'x', {}); |
| canDefineProperty = true; |
| } catch (x) { |
| // IE will fail on defineProperty |
| } |
| } |
| |
| module.exports = canDefineProperty; |
| },{}],118:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @typechecks static-only |
| * @providesModule cloneWithProps |
| */ |
| |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| var ReactPropTransferer = _dereq_(79); |
| |
| var keyOf = _dereq_(166); |
| var warning = _dereq_(173); |
| |
| var CHILDREN_PROP = keyOf({ children: null }); |
| |
| var didDeprecatedWarn = false; |
| |
| /** |
| * Sometimes you want to change the props of a child passed to you. Usually |
| * this is to add a CSS class. |
| * |
| * @param {ReactElement} child child element you'd like to clone |
| * @param {object} props props you'd like to modify. className and style will be |
| * merged automatically. |
| * @return {ReactElement} a clone of child with props merged in. |
| * @deprecated |
| */ |
| function cloneWithProps(child, props) { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(didDeprecatedWarn, 'cloneWithProps(...) is deprecated. ' + 'Please use React.cloneElement instead.') : undefined; |
| didDeprecatedWarn = true; |
| "development" !== 'production' ? warning(!child.ref, 'You are calling cloneWithProps() on a child with a ref. This is ' + 'dangerous because you\'re creating a new child which will not be ' + 'added as a ref to its parent.') : undefined; |
| } |
| |
| var newProps = ReactPropTransferer.mergeProps(props, child.props); |
| |
| // Use `child.props.children` if it is provided. |
| if (!newProps.hasOwnProperty(CHILDREN_PROP) && child.props.hasOwnProperty(CHILDREN_PROP)) { |
| newProps.children = child.props.children; |
| } |
| |
| // The current API doesn't retain _owner, which is why this |
| // doesn't use ReactElement.cloneAndReplaceProps. |
| return ReactElement.createElement(child.type, newProps); |
| } |
| |
| module.exports = cloneWithProps; |
| },{"166":166,"173":173,"57":57,"79":79}],119:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule dangerousStyleValue |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var CSSProperty = _dereq_(4); |
| |
| var isUnitlessNumber = CSSProperty.isUnitlessNumber; |
| |
| /** |
| * 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`. |
| * @return {string} Normalized style value with dimensions applied. |
| */ |
| function dangerousStyleValue(name, value) { |
| // 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') { |
| value = value.trim(); |
| } |
| return value + 'px'; |
| } |
| |
| module.exports = dangerousStyleValue; |
| },{"4":4}],120:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule deprecated |
| */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| var warning = _dereq_(173); |
| |
| /** |
| * This will log a single deprecation notice per function and forward the call |
| * on to the new API. |
| * |
| * @param {string} fnName The name of the function |
| * @param {string} newModule The module that fn will exist in |
| * @param {string} newPackage The module that fn will exist in |
| * @param {*} ctx The context this forwarded call should run in |
| * @param {function} fn The function to forward on to |
| * @return {function} The function that will warn once and then call fn |
| */ |
| function deprecated(fnName, newModule, newPackage, ctx, fn) { |
| var warned = false; |
| if ("development" !== 'production') { |
| var newFn = function () { |
| "development" !== 'production' ? warning(warned, |
| // Require examples in this string must be split to prevent React's |
| // build tools from mistaking them for real requires. |
| // Otherwise the build tools will attempt to build a '%s' module. |
| 'React.%s is deprecated. Please use %s.%s from require' + '(\'%s\') ' + 'instead.', fnName, newModule, fnName, newPackage) : undefined; |
| warned = true; |
| return fn.apply(ctx, arguments); |
| }; |
| // We need to make sure all properties of the original fn are copied over. |
| // In particular, this is needed to support PropTypes |
| return assign(newFn, fn); |
| } |
| |
| return fn; |
| } |
| |
| module.exports = deprecated; |
| },{"173":173,"24":24}],121:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule escapeTextContentForBrowser |
| */ |
| |
| 'use strict'; |
| |
| var ESCAPE_LOOKUP = { |
| '&': '&', |
| '>': '>', |
| '<': '<', |
| '"': '"', |
| '\'': ''' |
| }; |
| |
| var ESCAPE_REGEX = /[&><"']/g; |
| |
| function escaper(match) { |
| return ESCAPE_LOOKUP[match]; |
| } |
| |
| /** |
| * Escapes text to prevent scripting attacks. |
| * |
| * @param {*} text Text value to escape. |
| * @return {string} An escaped string. |
| */ |
| function escapeTextContentForBrowser(text) { |
| return ('' + text).replace(ESCAPE_REGEX, escaper); |
| } |
| |
| module.exports = escapeTextContentForBrowser; |
| },{}],122:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule findDOMNode |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactInstanceMap = _dereq_(68); |
| var ReactMount = _dereq_(72); |
| |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| /** |
| * Returns the DOM node rendered by this element. |
| * |
| * @param {ReactComponent|DOMElement} componentOrElement |
| * @return {?DOMElement} The root node of this element. |
| */ |
| function findDOMNode(componentOrElement) { |
| if ("development" !== 'production') { |
| var owner = ReactCurrentOwner.current; |
| if (owner !== null) { |
| "development" !== 'production' ? warning(owner._warnedAboutRefsInRender, '%s is accessing getDOMNode or findDOMNode inside its render(). ' + 'render() should be a pure function of props and state. It should ' + 'never access something that requires stale data from the previous ' + 'render, such as refs. Move this logic to componentDidMount and ' + 'componentDidUpdate instead.', owner.getName() || 'A component') : undefined; |
| owner._warnedAboutRefsInRender = true; |
| } |
| } |
| if (componentOrElement == null) { |
| return null; |
| } |
| if (componentOrElement.nodeType === 1) { |
| return componentOrElement; |
| } |
| if (ReactInstanceMap.has(componentOrElement)) { |
| return ReactMount.getNodeFromInstance(componentOrElement); |
| } |
| !(componentOrElement.render == null || typeof componentOrElement.render !== 'function') ? "development" !== 'production' ? invariant(false, 'findDOMNode was called on an unmounted component.') : invariant(false) : undefined; |
| !false ? "development" !== 'production' ? invariant(false, 'Element appears to be neither ReactComponent nor DOMNode (keys: %s)', Object.keys(componentOrElement)) : invariant(false) : undefined; |
| } |
| |
| module.exports = findDOMNode; |
| },{"161":161,"173":173,"39":39,"68":68,"72":72}],123:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule flattenChildren |
| */ |
| |
| 'use strict'; |
| |
| var traverseAllChildren = _dereq_(142); |
| var warning = _dereq_(173); |
| |
| /** |
| * @param {function} traverseContext Context passed through traversal. |
| * @param {?ReactComponent} child React child component. |
| * @param {!string} name String name of key path to child. |
| */ |
| function flattenSingleChildIntoContext(traverseContext, child, name) { |
| // We found a component instance. |
| var result = traverseContext; |
| var keyUnique = result[name] === undefined; |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(keyUnique, '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.', name) : undefined; |
| } |
| if (keyUnique && child != null) { |
| result[name] = child; |
| } |
| } |
| |
| /** |
| * 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. |
| */ |
| function flattenChildren(children) { |
| if (children == null) { |
| return children; |
| } |
| var result = {}; |
| traverseAllChildren(children, flattenSingleChildIntoContext, result); |
| return result; |
| } |
| |
| module.exports = flattenChildren; |
| },{"142":142,"173":173}],124:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule forEachAccumulated |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * @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). |
| */ |
| var forEachAccumulated = function (arr, cb, scope) { |
| if (Array.isArray(arr)) { |
| arr.forEach(cb, scope); |
| } else if (arr) { |
| cb.call(scope, arr); |
| } |
| }; |
| |
| module.exports = forEachAccumulated; |
| },{}],125:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getEventCharCode |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * `charCode` represents the actual "character code" and is safe to use with |
| * `String.fromCharCode`. As such, only keys that correspond to printable |
| * characters produce a valid `charCode`, the only exception to this is Enter. |
| * The Tab-key is considered non-printable and does not have a `charCode`, |
| * presumably because it does not produce a tab-character in browsers. |
| * |
| * @param {object} nativeEvent Native browser event. |
| * @return {number} Normalized `charCode` property. |
| */ |
| function getEventCharCode(nativeEvent) { |
| var charCode; |
| var keyCode = nativeEvent.keyCode; |
| |
| if ('charCode' in nativeEvent) { |
| charCode = nativeEvent.charCode; |
| |
| // FF does not set `charCode` for the Enter-key, check against `keyCode`. |
| if (charCode === 0 && keyCode === 13) { |
| charCode = 13; |
| } |
| } else { |
| // IE8 does not implement `charCode`, but `keyCode` has the correct value. |
| charCode = keyCode; |
| } |
| |
| // Some non-printable keys are reported in `charCode`/`keyCode`, discard them. |
| // Must not discard the (non-)printable Enter-key. |
| if (charCode >= 32 || charCode === 13) { |
| return charCode; |
| } |
| |
| return 0; |
| } |
| |
| module.exports = getEventCharCode; |
| },{}],126:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getEventKey |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var getEventCharCode = _dereq_(125); |
| |
| /** |
| * Normalization of deprecated HTML5 `key` values |
| * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names |
| */ |
| var normalizeKey = { |
| 'Esc': 'Escape', |
| 'Spacebar': ' ', |
| 'Left': 'ArrowLeft', |
| 'Up': 'ArrowUp', |
| 'Right': 'ArrowRight', |
| 'Down': 'ArrowDown', |
| 'Del': 'Delete', |
| 'Win': 'OS', |
| 'Menu': 'ContextMenu', |
| 'Apps': 'ContextMenu', |
| 'Scroll': 'ScrollLock', |
| 'MozPrintableKey': 'Unidentified' |
| }; |
| |
| /** |
| * Translation from legacy `keyCode` to HTML5 `key` |
| * Only special keys supported, all others depend on keyboard layout or browser |
| * @see https://developer.mozilla.org/en-US/docs/Web/API/KeyboardEvent#Key_names |
| */ |
| var translateToKey = { |
| 8: 'Backspace', |
| 9: 'Tab', |
| 12: 'Clear', |
| 13: 'Enter', |
| 16: 'Shift', |
| 17: 'Control', |
| 18: 'Alt', |
| 19: 'Pause', |
| 20: 'CapsLock', |
| 27: 'Escape', |
| 32: ' ', |
| 33: 'PageUp', |
| 34: 'PageDown', |
| 35: 'End', |
| 36: 'Home', |
| 37: 'ArrowLeft', |
| 38: 'ArrowUp', |
| 39: 'ArrowRight', |
| 40: 'ArrowDown', |
| 45: 'Insert', |
| 46: 'Delete', |
| 112: 'F1', 113: 'F2', 114: 'F3', 115: 'F4', 116: 'F5', 117: 'F6', |
| 118: 'F7', 119: 'F8', 120: 'F9', 121: 'F10', 122: 'F11', 123: 'F12', |
| 144: 'NumLock', |
| 145: 'ScrollLock', |
| 224: 'Meta' |
| }; |
| |
| /** |
| * @param {object} nativeEvent Native browser event. |
| * @return {string} Normalized `key` property. |
| */ |
| function getEventKey(nativeEvent) { |
| if (nativeEvent.key) { |
| // Normalize inconsistent values reported by browsers due to |
| // implementations of a working draft specification. |
| |
| // FireFox implements `key` but returns `MozPrintableKey` for all |
| // printable characters (normalized to `Unidentified`), ignore it. |
| var key = normalizeKey[nativeEvent.key] || nativeEvent.key; |
| if (key !== 'Unidentified') { |
| return key; |
| } |
| } |
| |
| // Browser does not implement `key`, polyfill as much of it as we can. |
| if (nativeEvent.type === 'keypress') { |
| var charCode = getEventCharCode(nativeEvent); |
| |
| // The enter-key is technically both printable and non-printable and can |
| // thus be captured by `keypress`, no other non-printable key should. |
| return charCode === 13 ? 'Enter' : String.fromCharCode(charCode); |
| } |
| if (nativeEvent.type === 'keydown' || nativeEvent.type === 'keyup') { |
| // While user keyboard layout determines the actual meaning of each |
| // `keyCode` value, almost all function keys have a universal value. |
| return translateToKey[nativeEvent.keyCode] || 'Unidentified'; |
| } |
| return ''; |
| } |
| |
| module.exports = getEventKey; |
| },{"125":125}],127:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getEventModifierState |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Translation from modifier key to the associated property in the event. |
| * @see http://www.w3.org/TR/DOM-Level-3-Events/#keys-Modifiers |
| */ |
| |
| var modifierKeyToProp = { |
| 'Alt': 'altKey', |
| 'Control': 'ctrlKey', |
| 'Meta': 'metaKey', |
| 'Shift': 'shiftKey' |
| }; |
| |
| // IE8 does not implement getModifierState so we simply map it to the only |
| // modifier keys exposed by the event itself, does not support Lock-keys. |
| // Currently, all major browsers except Chrome seems to support Lock-keys. |
| 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; |
| } |
| |
| function getEventModifierState(nativeEvent) { |
| return modifierStateGetter; |
| } |
| |
| module.exports = getEventModifierState; |
| },{}],128:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getEventTarget |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * 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. |
| */ |
| function getEventTarget(nativeEvent) { |
| var target = nativeEvent.target || nativeEvent.srcElement || window; |
| // 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; |
| } |
| |
| module.exports = getEventTarget; |
| },{}],129:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getIteratorFn |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /* global Symbol */ |
| var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator; |
| var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec. |
| |
| /** |
| * Returns the iterator method function contained on the iterable object. |
| * |
| * Be sure to invoke the function with the iterable as context: |
| * |
| * var iteratorFn = getIteratorFn(myIterable); |
| * if (iteratorFn) { |
| * var iterator = iteratorFn.call(myIterable); |
| * ... |
| * } |
| * |
| * @param {?object} maybeIterable |
| * @return {?function} |
| */ |
| function getIteratorFn(maybeIterable) { |
| var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]); |
| if (typeof iteratorFn === 'function') { |
| return iteratorFn; |
| } |
| } |
| |
| module.exports = getIteratorFn; |
| },{}],130:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getNodeForCharacterOffset |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Given any node return the first leaf node without children. |
| * |
| * @param {DOMElement|DOMTextNode} node |
| * @return {DOMElement|DOMTextNode} |
| */ |
| function getLeafNode(node) { |
| while (node && node.firstChild) { |
| node = node.firstChild; |
| } |
| return node; |
| } |
| |
| /** |
| * Get the next sibling within a container. This will walk up the |
| * DOM if a node's siblings have been exhausted. |
| * |
| * @param {DOMElement|DOMTextNode} node |
| * @return {?DOMElement|DOMTextNode} |
| */ |
| function getSiblingNode(node) { |
| while (node) { |
| if (node.nextSibling) { |
| return node.nextSibling; |
| } |
| node = node.parentNode; |
| } |
| } |
| |
| /** |
| * Get object describing the nodes which contain characters at offset. |
| * |
| * @param {DOMElement|DOMTextNode} root |
| * @param {number} offset |
| * @return {?object} |
| */ |
| function getNodeForCharacterOffset(root, offset) { |
| var node = getLeafNode(root); |
| var nodeStart = 0; |
| var nodeEnd = 0; |
| |
| while (node) { |
| if (node.nodeType === 3) { |
| nodeEnd = nodeStart + node.textContent.length; |
| |
| if (nodeStart <= offset && nodeEnd >= offset) { |
| return { |
| node: node, |
| offset: offset - nodeStart |
| }; |
| } |
| |
| nodeStart = nodeEnd; |
| } |
| |
| node = getLeafNode(getSiblingNode(node)); |
| } |
| } |
| |
| module.exports = getNodeForCharacterOffset; |
| },{}],131:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getTextContentAccessor |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var contentKey = null; |
| |
| /** |
| * Gets the key used to access text content on a DOM node. |
| * |
| * @return {?string} Key used to access text content. |
| * @internal |
| */ |
| 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; |
| } |
| |
| module.exports = getTextContentAccessor; |
| },{"147":147}],132:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule instantiateReactComponent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var ReactCompositeComponent = _dereq_(38); |
| var ReactEmptyComponent = _dereq_(59); |
| var ReactNativeComponent = _dereq_(75); |
| |
| var assign = _dereq_(24); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| // To avoid a cyclic dependency, we create the final class in this module |
| var ReactCompositeComponentWrapper = function () {}; |
| assign(ReactCompositeComponentWrapper.prototype, ReactCompositeComponent.Mixin, { |
| _instantiateReactComponent: instantiateReactComponent |
| }); |
| |
| function getDeclarationErrorAddendum(owner) { |
| if (owner) { |
| var name = owner.getName(); |
| if (name) { |
| return ' Check the render method of `' + name + '`.'; |
| } |
| } |
| return ''; |
| } |
| |
| /** |
| * 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. |
| */ |
| function isInternalComponentType(type) { |
| return typeof type === 'function' && typeof type.prototype !== 'undefined' && typeof type.prototype.mountComponent === 'function' && typeof type.prototype.receiveComponent === 'function'; |
| } |
| |
| /** |
| * Given a ReactNode, create an instance that will actually be mounted. |
| * |
| * @param {ReactNode} node |
| * @return {object} A new instance of the element's constructor. |
| * @protected |
| */ |
| function instantiateReactComponent(node) { |
| var instance; |
| |
| if (node === null || node === false) { |
| instance = new ReactEmptyComponent(instantiateReactComponent); |
| } else if (typeof node === 'object') { |
| var element = node; |
| !(element && (typeof element.type === 'function' || typeof element.type === 'string')) ? "development" !== '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', element.type == null ? element.type : typeof element.type, getDeclarationErrorAddendum(element._owner)) : invariant(false) : undefined; |
| |
| // Special case string values |
| if (typeof element.type === 'string') { |
| instance = ReactNativeComponent.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); |
| } else { |
| instance = new ReactCompositeComponentWrapper(); |
| } |
| } else if (typeof node === 'string' || typeof node === 'number') { |
| instance = ReactNativeComponent.createInstanceForText(node); |
| } else { |
| !false ? "development" !== 'production' ? invariant(false, 'Encountered invalid React node of type %s', typeof node) : invariant(false) : undefined; |
| } |
| |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(typeof instance.construct === 'function' && typeof instance.mountComponent === 'function' && typeof instance.receiveComponent === 'function' && typeof instance.unmountComponent === 'function', 'Only React Components can be mounted.') : undefined; |
| } |
| |
| // Sets up the instance. This can probably just move into the constructor now. |
| instance.construct(node); |
| |
| // 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 ("development" !== 'production') { |
| instance._isOwnerNecessary = false; |
| instance._warnedAboutRefsInRender = false; |
| } |
| |
| // Internal instances should fully constructed at this point, so they should |
| // not get any new fields added to them at this point. |
| if ("development" !== 'production') { |
| if (Object.preventExtensions) { |
| Object.preventExtensions(instance); |
| } |
| } |
| |
| return instance; |
| } |
| |
| module.exports = instantiateReactComponent; |
| },{"161":161,"173":173,"24":24,"38":38,"59":59,"75":75}],133:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule isEventSupported |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var useHasFeature; |
| if (ExecutionEnvironment.canUseDOM) { |
| useHasFeature = document.implementation && document.implementation.hasFeature && |
| // always returns true in newer browsers as per the standard. |
| // @see http://dom.spec.whatwg.org/#dom-domimplementation-hasfeature |
| document.implementation.hasFeature('', '') !== true; |
| } |
| |
| /** |
| * Checks if an event is supported in the current execution environment. |
| * |
| * NOTE: This will not work correctly for non-generic events such as `change`, |
| * `reset`, `load`, `error`, and `select`. |
| * |
| * Borrows from Modernizr. |
| * |
| * @param {string} eventNameSuffix Event name, e.g. "click". |
| * @param {?boolean} capture Check if the capture phase is supported. |
| * @return {boolean} True if the event is supported. |
| * @internal |
| * @license Modernizr 3.0.0pre (Custom Build) | MIT |
| */ |
| function isEventSupported(eventNameSuffix, capture) { |
| if (!ExecutionEnvironment.canUseDOM || capture && !('addEventListener' in document)) { |
| return false; |
| } |
| |
| var eventName = 'on' + eventNameSuffix; |
| var isSupported = (eventName in document); |
| |
| if (!isSupported) { |
| var element = document.createElement('div'); |
| element.setAttribute(eventName, 'return;'); |
| isSupported = typeof element[eventName] === 'function'; |
| } |
| |
| if (!isSupported && useHasFeature && eventNameSuffix === 'wheel') { |
| // This is the only way to test support for the `wheel` event in IE9+. |
| isSupported = document.implementation.hasFeature('Events.wheel', '3.0'); |
| } |
| |
| return isSupported; |
| } |
| |
| module.exports = isEventSupported; |
| },{"147":147}],134:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule isTextInputElement |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * @see http://www.whatwg.org/specs/web-apps/current-work/multipage/the-input-element.html#input-type-attr-summary |
| */ |
| var supportedInputTypes = { |
| 'color': true, |
| 'date': true, |
| 'datetime': true, |
| 'datetime-local': true, |
| 'email': true, |
| 'month': true, |
| 'number': true, |
| 'password': true, |
| 'range': true, |
| 'search': true, |
| 'tel': true, |
| 'text': true, |
| 'time': true, |
| 'url': true, |
| 'week': true |
| }; |
| |
| function isTextInputElement(elem) { |
| var nodeName = elem && elem.nodeName && elem.nodeName.toLowerCase(); |
| return nodeName && (nodeName === 'input' && supportedInputTypes[elem.type] || nodeName === 'textarea'); |
| } |
| |
| module.exports = isTextInputElement; |
| },{}],135:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule onlyChild |
| */ |
| 'use strict'; |
| |
| var ReactElement = _dereq_(57); |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Returns the first child in a collection of children and verifies that there |
| * is only one child in the collection. The current implementation of this |
| * function assumes that a single child gets passed without a wrapper, but the |
| * purpose of this helper function is to abstract away the particular structure |
| * of children. |
| * |
| * @param {?object} children Child collection structure. |
| * @return {ReactComponent} The first and only `ReactComponent` contained in the |
| * structure. |
| */ |
| function onlyChild(children) { |
| !ReactElement.isValidElement(children) ? "development" !== 'production' ? invariant(false, 'onlyChild must be passed a children with exactly one child.') : invariant(false) : undefined; |
| return children; |
| } |
| |
| module.exports = onlyChild; |
| },{"161":161,"57":57}],136:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule quoteAttributeValueForBrowser |
| */ |
| |
| 'use strict'; |
| |
| var escapeTextContentForBrowser = _dereq_(121); |
| |
| /** |
| * Escapes attribute value to prevent scripting attacks. |
| * |
| * @param {*} value Value to escape. |
| * @return {string} An escaped string. |
| */ |
| function quoteAttributeValueForBrowser(value) { |
| return '"' + escapeTextContentForBrowser(value) + '"'; |
| } |
| |
| module.exports = quoteAttributeValueForBrowser; |
| },{"121":121}],137:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule renderSubtreeIntoContainer |
| */ |
| |
| 'use strict'; |
| |
| var ReactMount = _dereq_(72); |
| |
| module.exports = ReactMount.renderSubtreeIntoContainer; |
| },{"72":72}],138:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule setInnerHTML |
| */ |
| |
| /* globals MSApp */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var WHITESPACE_TEST = /^[ \r\n\t\f]/; |
| var NONVISIBLE_TEST = /<(!--|link|noscript|meta|script|style)[ \r\n\t\f\/>]/; |
| |
| /** |
| * Set the innerHTML property of a node, ensuring that whitespace is preserved |
| * even in IE8. |
| * |
| * @param {DOMElement} node |
| * @param {string} html |
| * @internal |
| */ |
| var setInnerHTML = function (node, html) { |
| node.innerHTML = html; |
| }; |
| |
| // Win8 apps: Allow all html to be inserted |
| if (typeof MSApp !== 'undefined' && MSApp.execUnsafeLocalFunction) { |
| setInnerHTML = function (node, html) { |
| MSApp.execUnsafeLocalFunction(function () { |
| node.innerHTML = html; |
| }); |
| }; |
| } |
| |
| if (ExecutionEnvironment.canUseDOM) { |
| // IE8: When updating a just created node with innerHTML only leading |
| // whitespace is removed. When updating an existing node with innerHTML |
| // whitespace in root TextNodes is also collapsed. |
| // @see quirksmode.org/bugreports/archives/2004/11/innerhtml_and_t.html |
| |
| // Feature detection; only IE8 is known to behave improperly like this. |
| var testElement = document.createElement('div'); |
| testElement.innerHTML = ' '; |
| if (testElement.innerHTML === '') { |
| setInnerHTML = function (node, html) { |
| // Magic theory: IE8 supposedly differentiates between added and updated |
| // nodes when processing innerHTML, innerHTML on updated nodes suffers |
| // from worse whitespace behavior. Re-adding a node like this triggers |
| // the initial and more favorable whitespace behavior. |
| // TODO: What to do on a detached node? |
| if (node.parentNode) { |
| node.parentNode.replaceChild(node, node); |
| } |
| |
| // We also implement a workaround for non-visible tags disappearing into |
| // thin air on IE8, this only happens if there is no visible text |
| // in-front of the non-visible tags. Piggyback on the whitespace fix |
| // and simply check if any non-visible tags appear in the source. |
| if (WHITESPACE_TEST.test(html) || html[0] === '<' && NONVISIBLE_TEST.test(html)) { |
| // Recover leading whitespace by temporarily prepending any character. |
| // \uFEFF has the potential advantage of being zero-width/invisible. |
| // UglifyJS drops U+FEFF chars when parsing, so use String.fromCharCode |
| // in hopes that this is preserved even if "\uFEFF" is transformed to |
| // the actual Unicode character (by Babel, for example). |
| // https://github.com/mishoo/UglifyJS2/blob/v2.4.20/lib/parse.js#L216 |
| node.innerHTML = String.fromCharCode(0xFEFF) + html; |
| |
| // deleteData leaves an empty `TextNode` which offsets the index of all |
| // children. Definitely want to avoid this. |
| var textNode = node.firstChild; |
| if (textNode.data.length === 1) { |
| node.removeChild(textNode); |
| } else { |
| textNode.deleteData(0, 1); |
| } |
| } else { |
| node.innerHTML = html; |
| } |
| }; |
| } |
| } |
| |
| module.exports = setInnerHTML; |
| },{"147":147}],139:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule setTextContent |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| var escapeTextContentForBrowser = _dereq_(121); |
| var setInnerHTML = _dereq_(138); |
| |
| /** |
| * 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 |
| */ |
| var setTextContent = function (node, text) { |
| node.textContent = text; |
| }; |
| |
| if (ExecutionEnvironment.canUseDOM) { |
| if (!('textContent' in document.documentElement)) { |
| setTextContent = function (node, text) { |
| setInnerHTML(node, escapeTextContentForBrowser(text)); |
| }; |
| } |
| } |
| |
| module.exports = setTextContent; |
| },{"121":121,"138":138,"147":147}],140:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule shallowCompare |
| */ |
| |
| 'use strict'; |
| |
| var shallowEqual = _dereq_(171); |
| |
| /** |
| * Does a shallow comparison for props and state. |
| * See ReactComponentWithPureRenderMixin |
| */ |
| function shallowCompare(instance, nextProps, nextState) { |
| return !shallowEqual(instance.props, nextProps) || !shallowEqual(instance.state, nextState); |
| } |
| |
| module.exports = shallowCompare; |
| },{"171":171}],141:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule shouldUpdateReactComponent |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * 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 |
| */ |
| 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; |
| } |
| return false; |
| } |
| |
| module.exports = shouldUpdateReactComponent; |
| },{}],142:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule traverseAllChildren |
| */ |
| |
| 'use strict'; |
| |
| var ReactCurrentOwner = _dereq_(39); |
| var ReactElement = _dereq_(57); |
| var ReactInstanceHandles = _dereq_(67); |
| |
| var getIteratorFn = _dereq_(129); |
| var invariant = _dereq_(161); |
| var warning = _dereq_(173); |
| |
| var SEPARATOR = ReactInstanceHandles.SEPARATOR; |
| var SUBSEPARATOR = ':'; |
| |
| /** |
| * TODO: Test that a single child and an array with one item have the same key |
| * pattern. |
| */ |
| |
| var userProvidedKeyEscaperLookup = { |
| '=': '=0', |
| '.': '=1', |
| ':': '=2' |
| }; |
| |
| var userProvidedKeyEscapeRegex = /[=.:]/g; |
| |
| var didWarnAboutMaps = false; |
| |
| function userProvidedKeyEscaper(match) { |
| return userProvidedKeyEscaperLookup[match]; |
| } |
| |
| /** |
| * Generate a key string that identifies a component within a set. |
| * |
| * @param {*} component A component that could contain a manual key. |
| * @param {number} index Index that is used if a manual key is not provided. |
| * @return {string} |
| */ |
| function getComponentKey(component, index) { |
| if (component && component.key != null) { |
| // Explicit key |
| return wrapUserProvidedKey(component.key); |
| } |
| // Implicit key determined by the index in the set |
| return index.toString(36); |
| } |
| |
| /** |
| * Escape a component key so that it is safe to use in a reactid. |
| * |
| * @param {*} text Component key to be escaped. |
| * @return {string} An escaped string. |
| */ |
| function escapeUserProvidedKey(text) { |
| return ('' + text).replace(userProvidedKeyEscapeRegex, userProvidedKeyEscaper); |
| } |
| |
| /** |
| * Wrap a `key` value explicitly provided by the user to distinguish it from |
| * implicitly-generated keys generated by a component's index in its parent. |
| * |
| * @param {string} key Value of a user-provided `key` attribute |
| * @return {string} |
| */ |
| function wrapUserProvidedKey(key) { |
| return '$' + escapeUserProvidedKey(key); |
| } |
| |
| /** |
| * @param {?*} children Children tree container. |
| * @param {!string} nameSoFar Name of the key path so far. |
| * @param {!function} callback Callback to invoke with each child found. |
| * @param {?*} traverseContext Used to pass information throughout the traversal |
| * process. |
| * @return {!number} The number of children in this subtree. |
| */ |
| function traverseAllChildrenImpl(children, nameSoFar, callback, traverseContext) { |
| var type = typeof children; |
| |
| if (type === 'undefined' || type === 'boolean') { |
| // All of the above are perceived as null. |
| children = null; |
| } |
| |
| if (children === null || type === 'string' || type === 'number' || ReactElement.isValidElement(children)) { |
| callback(traverseContext, children, |
| // If it's the only child, treat the name as if it was wrapped in an array |
| // so that it's consistent if the number of children grows. |
| nameSoFar === '' ? SEPARATOR + getComponentKey(children, 0) : nameSoFar); |
| return 1; |
| } |
| |
| var child; |
| var nextName; |
| var subtreeCount = 0; // Count of children found in the current subtree. |
| var nextNamePrefix = nameSoFar === '' ? SEPARATOR : nameSoFar + SUBSEPARATOR; |
| |
| if (Array.isArray(children)) { |
| for (var i = 0; i < children.length; i++) { |
| child = children[i]; |
| nextName = nextNamePrefix + getComponentKey(child, i); |
| subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); |
| } |
| } else { |
| var iteratorFn = getIteratorFn(children); |
| if (iteratorFn) { |
| var iterator = iteratorFn.call(children); |
| var step; |
| if (iteratorFn !== children.entries) { |
| var ii = 0; |
| while (!(step = iterator.next()).done) { |
| child = step.value; |
| nextName = nextNamePrefix + getComponentKey(child, ii++); |
| subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); |
| } |
| } else { |
| if ("development" !== 'production') { |
| "development" !== 'production' ? warning(didWarnAboutMaps, 'Using Maps as children is not yet fully supported. It is an ' + 'experimental feature that might be removed. Convert it to a ' + 'sequence / iterable of keyed ReactElements instead.') : undefined; |
| didWarnAboutMaps = true; |
| } |
| // Iterator will provide entry [k,v] tuples rather than values. |
| while (!(step = iterator.next()).done) { |
| var entry = step.value; |
| if (entry) { |
| child = entry[1]; |
| nextName = nextNamePrefix + wrapUserProvidedKey(entry[0]) + SUBSEPARATOR + getComponentKey(child, 0); |
| subtreeCount += traverseAllChildrenImpl(child, nextName, callback, traverseContext); |
| } |
| } |
| } |
| } else if (type === 'object') { |
| var addendum = ''; |
| if ("development" !== 'production') { |
| addendum = ' If you meant to render a collection of children, use an array ' + 'instead or wrap the object using createFragment(object) from the ' + 'React add-ons.'; |
| if (children._isReactElement) { |
| addendum = ' It looks like you\'re using an element created by a different ' + 'version of React. Make sure to use only one copy of React.'; |
| } |
| if (ReactCurrentOwner.current) { |
| var name = ReactCurrentOwner.current.getName(); |
| if (name) { |
| addendum += ' Check the render method of `' + name + '`.'; |
| } |
| } |
| } |
| var childrenString = String(children); |
| !false ? "development" !== 'production' ? invariant(false, 'Objects are not valid as a React child (found: %s).%s', childrenString === '[object Object]' ? 'object with keys {' + Object.keys(children).join(', ') + '}' : childrenString, addendum) : invariant(false) : undefined; |
| } |
| } |
| |
| return subtreeCount; |
| } |
| |
| /** |
| * Traverses children that are typically specified as `props.children`, but |
| * might also be specified through attributes: |
| * |
| * - `traverseAllChildren(this.props.children, ...)` |
| * - `traverseAllChildren(this.props.leftPanelChildren, ...)` |
| * |
| * The `traverseContext` is an optional argument that is passed through the |
| * entire traversal. It can be used to store accumulations or anything else that |
| * the callback might find relevant. |
| * |
| * @param {?*} children Children tree object. |
| * @param {!function} callback To invoke upon traversing each child. |
| * @param {?*} traverseContext Context for traversal. |
| * @return {!number} The number of children in this subtree. |
| */ |
| function traverseAllChildren(children, callback, traverseContext) { |
| if (children == null) { |
| return 0; |
| } |
| |
| return traverseAllChildrenImpl(children, '', callback, traverseContext); |
| } |
| |
| module.exports = traverseAllChildren; |
| },{"129":129,"161":161,"173":173,"39":39,"57":57,"67":67}],143:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule update |
| */ |
| |
| /* global hasOwnProperty:true */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| var keyOf = _dereq_(166); |
| var invariant = _dereq_(161); |
| var hasOwnProperty = ({}).hasOwnProperty; |
| |
| function shallowCopy(x) { |
| if (Array.isArray(x)) { |
| return x.concat(); |
| } else if (x && typeof x === 'object') { |
| return assign(new x.constructor(), x); |
| } else { |
| return x; |
| } |
| } |
| |
| var COMMAND_PUSH = keyOf({ $push: null }); |
| var COMMAND_UNSHIFT = keyOf({ $unshift: null }); |
| var COMMAND_SPLICE = keyOf({ $splice: null }); |
| var COMMAND_SET = keyOf({ $set: null }); |
| var COMMAND_MERGE = keyOf({ $merge: null }); |
| var COMMAND_APPLY = keyOf({ $apply: null }); |
| |
| var ALL_COMMANDS_LIST = [COMMAND_PUSH, COMMAND_UNSHIFT, COMMAND_SPLICE, COMMAND_SET, COMMAND_MERGE, COMMAND_APPLY]; |
| |
| var ALL_COMMANDS_SET = {}; |
| |
| ALL_COMMANDS_LIST.forEach(function (command) { |
| ALL_COMMANDS_SET[command] = true; |
| }); |
| |
| function invariantArrayCase(value, spec, command) { |
| !Array.isArray(value) ? "development" !== 'production' ? invariant(false, 'update(): expected target of %s to be an array; got %s.', command, value) : invariant(false) : undefined; |
| var specValue = spec[command]; |
| !Array.isArray(specValue) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array; got %s. ' + 'Did you forget to wrap your parameter in an array?', command, specValue) : invariant(false) : undefined; |
| } |
| |
| function update(value, spec) { |
| !(typeof spec === 'object') ? "development" !== 'production' ? invariant(false, 'update(): You provided a key path to update() that did not contain one ' + 'of %s. Did you forget to include {%s: ...}?', ALL_COMMANDS_LIST.join(', '), COMMAND_SET) : invariant(false) : undefined; |
| |
| if (hasOwnProperty.call(spec, COMMAND_SET)) { |
| !(Object.keys(spec).length === 1) ? "development" !== 'production' ? invariant(false, 'Cannot have more than one key in an object with %s', COMMAND_SET) : invariant(false) : undefined; |
| |
| return spec[COMMAND_SET]; |
| } |
| |
| var nextValue = shallowCopy(value); |
| |
| if (hasOwnProperty.call(spec, COMMAND_MERGE)) { |
| var mergeObj = spec[COMMAND_MERGE]; |
| !(mergeObj && typeof mergeObj === 'object') ? "development" !== 'production' ? invariant(false, 'update(): %s expects a spec of type \'object\'; got %s', COMMAND_MERGE, mergeObj) : invariant(false) : undefined; |
| !(nextValue && typeof nextValue === 'object') ? "development" !== 'production' ? invariant(false, 'update(): %s expects a target of type \'object\'; got %s', COMMAND_MERGE, nextValue) : invariant(false) : undefined; |
| assign(nextValue, spec[COMMAND_MERGE]); |
| } |
| |
| if (hasOwnProperty.call(spec, COMMAND_PUSH)) { |
| invariantArrayCase(value, spec, COMMAND_PUSH); |
| spec[COMMAND_PUSH].forEach(function (item) { |
| nextValue.push(item); |
| }); |
| } |
| |
| if (hasOwnProperty.call(spec, COMMAND_UNSHIFT)) { |
| invariantArrayCase(value, spec, COMMAND_UNSHIFT); |
| spec[COMMAND_UNSHIFT].forEach(function (item) { |
| nextValue.unshift(item); |
| }); |
| } |
| |
| if (hasOwnProperty.call(spec, COMMAND_SPLICE)) { |
| !Array.isArray(value) ? "development" !== 'production' ? invariant(false, 'Expected %s target to be an array; got %s', COMMAND_SPLICE, value) : invariant(false) : undefined; |
| !Array.isArray(spec[COMMAND_SPLICE]) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. ' + 'Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : invariant(false) : undefined; |
| spec[COMMAND_SPLICE].forEach(function (args) { |
| !Array.isArray(args) ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be an array of arrays; got %s. ' + 'Did you forget to wrap your parameters in an array?', COMMAND_SPLICE, spec[COMMAND_SPLICE]) : invariant(false) : undefined; |
| nextValue.splice.apply(nextValue, args); |
| }); |
| } |
| |
| if (hasOwnProperty.call(spec, COMMAND_APPLY)) { |
| !(typeof spec[COMMAND_APPLY] === 'function') ? "development" !== 'production' ? invariant(false, 'update(): expected spec of %s to be a function; got %s.', COMMAND_APPLY, spec[COMMAND_APPLY]) : invariant(false) : undefined; |
| nextValue = spec[COMMAND_APPLY](nextValue); |
| } |
| |
| for (var k in spec) { |
| if (!(ALL_COMMANDS_SET.hasOwnProperty(k) && ALL_COMMANDS_SET[k])) { |
| nextValue[k] = update(value[k], spec[k]); |
| } |
| } |
| |
| return nextValue; |
| } |
| |
| module.exports = update; |
| },{"161":161,"166":166,"24":24}],144:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule validateDOMNesting |
| */ |
| |
| 'use strict'; |
| |
| var assign = _dereq_(24); |
| var emptyFunction = _dereq_(153); |
| var warning = _dereq_(173); |
| |
| var validateDOMNesting = emptyFunction; |
| |
| if ("development" !== 'production') { |
| // This validation code was written based on the HTML5 parsing spec: |
| // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope |
| // |
| // Note: this does not catch all invalid nesting, nor does it try to (as it's |
| // not clear what practical benefit doing so provides); instead, we warn only |
| // for cases where the parser will give a parse tree differing from what React |
| // intended. For example, <b><div></div></b> is invalid but we don't warn |
| // because it still parses correctly; we do warn for other cases like nested |
| // <p> tags where the beginning of the second element implicitly closes the |
| // first, causing a confusing mess. |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#special |
| var specialTags = ['address', 'applet', 'area', 'article', 'aside', 'base', 'basefont', 'bgsound', 'blockquote', 'body', 'br', 'button', 'caption', 'center', 'col', 'colgroup', 'dd', 'details', 'dir', 'div', 'dl', 'dt', 'embed', 'fieldset', 'figcaption', 'figure', 'footer', 'form', 'frame', 'frameset', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'iframe', 'img', 'input', 'isindex', 'li', 'link', 'listing', 'main', 'marquee', 'menu', 'menuitem', 'meta', 'nav', 'noembed', 'noframes', 'noscript', 'object', 'ol', 'p', 'param', 'plaintext', 'pre', 'script', 'section', 'select', 'source', 'style', 'summary', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'title', 'tr', 'track', 'ul', 'wbr', 'xmp']; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-scope |
| var inScopeTags = ['applet', 'caption', 'html', 'table', 'td', 'th', 'marquee', 'object', 'template', |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#html-integration-point |
| // TODO: Distinguish by namespace here -- for <title>, including it here |
| // errs on the side of fewer warnings |
| 'foreignObject', 'desc', 'title']; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#has-an-element-in-button-scope |
| var buttonScopeTags = inScopeTags.concat(['button']); |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#generate-implied-end-tags |
| var impliedEndTags = ['dd', 'dt', 'li', 'option', 'optgroup', 'p', 'rp', 'rt']; |
| |
| var emptyAncestorInfo = { |
| parentTag: null, |
| |
| formTag: null, |
| aTagInScope: null, |
| buttonTagInScope: null, |
| nobrTagInScope: null, |
| pTagInButtonScope: null, |
| |
| listItemTagAutoclosing: null, |
| dlItemTagAutoclosing: null |
| }; |
| |
| var updatedAncestorInfo = function (oldInfo, tag, instance) { |
| var ancestorInfo = assign({}, oldInfo || emptyAncestorInfo); |
| var info = { tag: tag, instance: instance }; |
| |
| if (inScopeTags.indexOf(tag) !== -1) { |
| ancestorInfo.aTagInScope = null; |
| ancestorInfo.buttonTagInScope = null; |
| ancestorInfo.nobrTagInScope = null; |
| } |
| if (buttonScopeTags.indexOf(tag) !== -1) { |
| ancestorInfo.pTagInButtonScope = null; |
| } |
| |
| // See rules for 'li', 'dd', 'dt' start tags in |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody |
| if (specialTags.indexOf(tag) !== -1 && tag !== 'address' && tag !== 'div' && tag !== 'p') { |
| ancestorInfo.listItemTagAutoclosing = null; |
| ancestorInfo.dlItemTagAutoclosing = null; |
| } |
| |
| ancestorInfo.parentTag = info; |
| |
| if (tag === 'form') { |
| ancestorInfo.formTag = info; |
| } |
| if (tag === 'a') { |
| ancestorInfo.aTagInScope = info; |
| } |
| if (tag === 'button') { |
| ancestorInfo.buttonTagInScope = info; |
| } |
| if (tag === 'nobr') { |
| ancestorInfo.nobrTagInScope = info; |
| } |
| if (tag === 'p') { |
| ancestorInfo.pTagInButtonScope = info; |
| } |
| if (tag === 'li') { |
| ancestorInfo.listItemTagAutoclosing = info; |
| } |
| if (tag === 'dd' || tag === 'dt') { |
| ancestorInfo.dlItemTagAutoclosing = info; |
| } |
| |
| return ancestorInfo; |
| }; |
| |
| /** |
| * Returns whether |
| */ |
| var isTagValidWithParent = function (tag, parentTag) { |
| // First, let's check if we're in an unusual parsing mode... |
| switch (parentTag) { |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inselect |
| case 'select': |
| return tag === 'option' || tag === 'optgroup' || tag === '#text'; |
| case 'optgroup': |
| return tag === 'option' || tag === '#text'; |
| // Strictly speaking, seeing an <option> doesn't mean we're in a <select> |
| // but |
| case 'option': |
| return tag === '#text'; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intd |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incaption |
| // No special behavior since these rules fall back to "in body" mode for |
| // all except special table nodes which cause bad parsing behavior anyway. |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intr |
| case 'tr': |
| return tag === 'th' || tag === 'td' || tag === 'style' || tag === 'script' || tag === 'template'; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intbody |
| case 'tbody': |
| case 'thead': |
| case 'tfoot': |
| return tag === 'tr' || tag === 'style' || tag === 'script' || tag === 'template'; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-incolgroup |
| case 'colgroup': |
| return tag === 'col' || tag === 'template'; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-intable |
| case 'table': |
| return tag === 'caption' || tag === 'colgroup' || tag === 'tbody' || tag === 'tfoot' || tag === 'thead' || tag === 'style' || tag === 'script' || tag === 'template'; |
| |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inhead |
| case 'head': |
| return tag === 'base' || tag === 'basefont' || tag === 'bgsound' || tag === 'link' || tag === 'meta' || tag === 'title' || tag === 'noscript' || tag === 'noframes' || tag === 'style' || tag === 'script' || tag === 'template'; |
| |
| // https://html.spec.whatwg.org/multipage/semantics.html#the-html-element |
| case 'html': |
| return tag === 'head' || tag === 'body'; |
| } |
| |
| // Probably in the "in body" parsing mode, so we outlaw only tag combos |
| // where the parsing rules cause implicit opens or closes to be added. |
| // https://html.spec.whatwg.org/multipage/syntax.html#parsing-main-inbody |
| switch (tag) { |
| case 'h1': |
| case 'h2': |
| case 'h3': |
| case 'h4': |
| case 'h5': |
| case 'h6': |
| return parentTag !== 'h1' && parentTag !== 'h2' && parentTag !== 'h3' && parentTag !== 'h4' && parentTag !== 'h5' && parentTag !== 'h6'; |
| |
| case 'rp': |
| case 'rt': |
| return impliedEndTags.indexOf(parentTag) === -1; |
| |
| case 'caption': |
| case 'col': |
| case 'colgroup': |
| case 'frame': |
| case 'head': |
| case 'tbody': |
| case 'td': |
| case 'tfoot': |
| case 'th': |
| case 'thead': |
| case 'tr': |
| // These tags are only valid with a few parents that have special child |
| // parsing rules -- if we're down here, then none of those matched and |
| // so we allow it only if we don't know what the parent is, as all other |
| // cases are invalid. |
| return parentTag == null; |
| } |
| |
| return true; |
| }; |
| |
| /** |
| * Returns whether |
| */ |
| var findInvalidAncestorForTag = function (tag, ancestorInfo) { |
| switch (tag) { |
| case 'address': |
| case 'article': |
| case 'aside': |
| case 'blockquote': |
| case 'center': |
| case 'details': |
| case 'dialog': |
| case 'dir': |
| case 'div': |
| case 'dl': |
| case 'fieldset': |
| case 'figcaption': |
| case 'figure': |
| case 'footer': |
| case 'header': |
| case 'hgroup': |
| case 'main': |
| case 'menu': |
| case 'nav': |
| case 'ol': |
| case 'p': |
| case 'section': |
| case 'summary': |
| case 'ul': |
| |
| case 'pre': |
| case 'listing': |
| |
| case 'table': |
| |
| case 'hr': |
| |
| case 'xmp': |
| |
| case 'h1': |
| case 'h2': |
| case 'h3': |
| case 'h4': |
| case 'h5': |
| case 'h6': |
| return ancestorInfo.pTagInButtonScope; |
| |
| case 'form': |
| return ancestorInfo.formTag || ancestorInfo.pTagInButtonScope; |
| |
| case 'li': |
| return ancestorInfo.listItemTagAutoclosing; |
| |
| case 'dd': |
| case 'dt': |
| return ancestorInfo.dlItemTagAutoclosing; |
| |
| case 'button': |
| return ancestorInfo.buttonTagInScope; |
| |
| case 'a': |
| // Spec says something about storing a list of markers, but it sounds |
| // equivalent to this check. |
| return ancestorInfo.aTagInScope; |
| |
| case 'nobr': |
| return ancestorInfo.nobrTagInScope; |
| } |
| |
| return null; |
| }; |
| |
| /** |
| * Given a ReactCompositeComponent instance, return a list of its recursive |
| * owners, starting at the root and ending with the instance itself. |
| */ |
| var findOwnerStack = function (instance) { |
| if (!instance) { |
| return []; |
| } |
| |
| var stack = []; |
| /*eslint-disable space-after-keywords */ |
| do { |
| /*eslint-enable space-after-keywords */ |
| stack.push(instance); |
| } while (instance = instance._currentElement._owner); |
| stack.reverse(); |
| return stack; |
| }; |
| |
| var didWarn = {}; |
| |
| validateDOMNesting = function (childTag, childInstance, ancestorInfo) { |
| ancestorInfo = ancestorInfo || emptyAncestorInfo; |
| var parentInfo = ancestorInfo.parentTag; |
| var parentTag = parentInfo && parentInfo.tag; |
| |
| var invalidParent = isTagValidWithParent(childTag, parentTag) ? null : parentInfo; |
| var invalidAncestor = invalidParent ? null : findInvalidAncestorForTag(childTag, ancestorInfo); |
| var problematic = invalidParent || invalidAncestor; |
| |
| if (problematic) { |
| var ancestorTag = problematic.tag; |
| var ancestorInstance = problematic.instance; |
| |
| var childOwner = childInstance && childInstance._currentElement._owner; |
| var ancestorOwner = ancestorInstance && ancestorInstance._currentElement._owner; |
| |
| var childOwners = findOwnerStack(childOwner); |
| var ancestorOwners = findOwnerStack(ancestorOwner); |
| |
| var minStackLen = Math.min(childOwners.length, ancestorOwners.length); |
| var i; |
| |
| var deepestCommon = -1; |
| for (i = 0; i < minStackLen; i++) { |
| if (childOwners[i] === ancestorOwners[i]) { |
| deepestCommon = i; |
| } else { |
| break; |
| } |
| } |
| |
| var UNKNOWN = '(unknown)'; |
| var childOwnerNames = childOwners.slice(deepestCommon + 1).map(function (inst) { |
| return inst.getName() || UNKNOWN; |
| }); |
| var ancestorOwnerNames = ancestorOwners.slice(deepestCommon + 1).map(function (inst) { |
| return inst.getName() || UNKNOWN; |
| }); |
| var ownerInfo = [].concat( |
| // If the parent and child instances have a common owner ancestor, start |
| // with that -- otherwise we just start with the parent's owners. |
| deepestCommon !== -1 ? childOwners[deepestCommon].getName() || UNKNOWN : [], ancestorOwnerNames, ancestorTag, |
| // If we're warning about an invalid (non-parent) ancestry, add '...' |
| invalidAncestor ? ['...'] : [], childOwnerNames, childTag).join(' > '); |
| |
| var warnKey = !!invalidParent + '|' + childTag + '|' + ancestorTag + '|' + ownerInfo; |
| if (didWarn[warnKey]) { |
| return; |
| } |
| didWarn[warnKey] = true; |
| |
| if (invalidParent) { |
| var info = ''; |
| if (ancestorTag === 'table' && childTag === 'tr') { |
| info += ' Add a <tbody> to your code to match the DOM tree generated by ' + 'the browser.'; |
| } |
| "development" !== 'production' ? warning(false, 'validateDOMNesting(...): <%s> cannot appear as a child of <%s>. ' + 'See %s.%s', childTag, ancestorTag, ownerInfo, info) : undefined; |
| } else { |
| "development" !== 'production' ? warning(false, 'validateDOMNesting(...): <%s> cannot appear as a descendant of ' + '<%s>. See %s.', childTag, ancestorTag, ownerInfo) : undefined; |
| } |
| } |
| }; |
| |
| validateDOMNesting.ancestorInfoContextKey = '__validateDOMNesting_ancestorInfo$' + Math.random().toString(36).slice(2); |
| |
| validateDOMNesting.updatedAncestorInfo = updatedAncestorInfo; |
| |
| // For testing |
| validateDOMNesting.isTagValidInContext = function (tag, ancestorInfo) { |
| ancestorInfo = ancestorInfo || emptyAncestorInfo; |
| var parentInfo = ancestorInfo.parentTag; |
| var parentTag = parentInfo && parentInfo.tag; |
| return isTagValidWithParent(tag, parentTag) && !findInvalidAncestorForTag(tag, ancestorInfo); |
| }; |
| } |
| |
| module.exports = validateDOMNesting; |
| },{"153":153,"173":173,"24":24}],145:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule CSSCore |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * The CSSCore module specifies the API (and implements most of the methods) |
| * that should be used when dealing with the display of elements (via their |
| * CSS classes and visibility on screen. It is an API focused on mutating the |
| * display and not reading it as no logical state should be encoded in the |
| * display of elements. |
| */ |
| |
| var CSSCore = { |
| |
| /** |
| * Adds the class passed in to the element if it doesn't already have it. |
| * |
| * @param {DOMElement} element the element to set the class on |
| * @param {string} className the CSS className |
| * @return {DOMElement} the element passed in |
| */ |
| addClass: function (element, className) { |
| !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSSCore.addClass takes only a single class name. "%s" contains ' + 'multiple classes.', className) : invariant(false) : undefined; |
| |
| if (className) { |
| if (element.classList) { |
| element.classList.add(className); |
| } else if (!CSSCore.hasClass(element, className)) { |
| element.className = element.className + ' ' + className; |
| } |
| } |
| return element; |
| }, |
| |
| /** |
| * Removes the class passed in from the element |
| * |
| * @param {DOMElement} element the element to set the class on |
| * @param {string} className the CSS className |
| * @return {DOMElement} the element passed in |
| */ |
| removeClass: function (element, className) { |
| !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSSCore.removeClass takes only a single class name. "%s" contains ' + 'multiple classes.', className) : invariant(false) : undefined; |
| |
| if (className) { |
| if (element.classList) { |
| element.classList.remove(className); |
| } else if (CSSCore.hasClass(element, className)) { |
| element.className = element.className.replace(new RegExp('(^|\\s)' + className + '(?:\\s|$)', 'g'), '$1').replace(/\s+/g, ' ') // multiple spaces to one |
| .replace(/^\s*|\s*$/g, ''); // trim the ends |
| } |
| } |
| return element; |
| }, |
| |
| /** |
| * Helper to add or remove a class from an element based on a condition. |
| * |
| * @param {DOMElement} element the element to set the class on |
| * @param {string} className the CSS className |
| * @param {*} bool condition to whether to add or remove the class |
| * @return {DOMElement} the element passed in |
| */ |
| conditionClass: function (element, className, bool) { |
| return (bool ? CSSCore.addClass : CSSCore.removeClass)(element, className); |
| }, |
| |
| /** |
| * Tests whether the element has the class specified. |
| * |
| * @param {DOMNode|DOMWindow} element the element to set the class on |
| * @param {string} className the CSS className |
| * @return {boolean} true if the element has the class, false if not |
| */ |
| hasClass: function (element, className) { |
| !!/\s/.test(className) ? "development" !== 'production' ? invariant(false, 'CSS.hasClass takes only a single class name.') : invariant(false) : undefined; |
| if (element.classList) { |
| return !!className && element.classList.contains(className); |
| } |
| return (' ' + element.className + ' ').indexOf(' ' + className + ' ') > -1; |
| } |
| |
| }; |
| |
| module.exports = CSSCore; |
| },{"161":161}],146:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * @providesModule EventListener |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var emptyFunction = _dereq_(153); |
| |
| /** |
| * Upstream version of event listener. Does not take into account specific |
| * nature of platform. |
| */ |
| var EventListener = { |
| /** |
| * Listen to DOM events during the bubble phase. |
| * |
| * @param {DOMEventTarget} target DOM element to register listener on. |
| * @param {string} eventType Event type, e.g. 'click' or 'mouseover'. |
| * @param {function} callback Callback function. |
| * @return {object} Object with a `remove` method. |
| */ |
| listen: function (target, eventType, callback) { |
| if (target.addEventListener) { |
| target.addEventListener(eventType, callback, false); |
| return { |
| remove: function () { |
| target.removeEventListener(eventType, callback, false); |
| } |
| }; |
| } else if (target.attachEvent) { |
| target.attachEvent('on' + eventType, callback); |
| return { |
| remove: function () { |
| target.detachEvent('on' + eventType, callback); |
| } |
| }; |
| } |
| }, |
| |
| /** |
| * Listen to DOM events during the capture phase. |
| * |
| * @param {DOMEventTarget} target DOM element to register listener on. |
| * @param {string} eventType Event type, e.g. 'click' or 'mouseover'. |
| * @param {function} callback Callback function. |
| * @return {object} Object with a `remove` method. |
| */ |
| capture: function (target, eventType, callback) { |
| if (target.addEventListener) { |
| target.addEventListener(eventType, callback, true); |
| return { |
| remove: function () { |
| target.removeEventListener(eventType, callback, true); |
| } |
| }; |
| } else { |
| if ("development" !== 'production') { |
| console.error('Attempted to listen to events during the capture phase on a ' + 'browser that does not support the capture phase. Your application ' + 'will not receive some events.'); |
| } |
| return { |
| remove: emptyFunction |
| }; |
| } |
| }, |
| |
| registerDefault: function () {} |
| }; |
| |
| module.exports = EventListener; |
| },{"153":153}],147:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule ExecutionEnvironment |
| */ |
| |
| 'use strict'; |
| |
| var canUseDOM = !!(typeof window !== 'undefined' && window.document && window.document.createElement); |
| |
| /** |
| * Simple, lightweight module assisting with the detection and context of |
| * Worker. Helps avoid circular dependencies and allows code to reason about |
| * whether or not they are in a Worker, even if they never include the main |
| * `ReactWorker` dependency. |
| */ |
| var ExecutionEnvironment = { |
| |
| canUseDOM: canUseDOM, |
| |
| canUseWorkers: typeof Worker !== 'undefined', |
| |
| canUseEventListeners: canUseDOM && !!(window.addEventListener || window.attachEvent), |
| |
| canUseViewport: canUseDOM && !!window.screen, |
| |
| isInWorker: !canUseDOM // For now, this is true - might change in the future. |
| |
| }; |
| |
| module.exports = ExecutionEnvironment; |
| },{}],148:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule camelize |
| * @typechecks |
| */ |
| |
| "use strict"; |
| |
| var _hyphenPattern = /-(.)/g; |
| |
| /** |
| * Camelcases a hyphenated string, for example: |
| * |
| * > camelize('background-color') |
| * < "backgroundColor" |
| * |
| * @param {string} string |
| * @return {string} |
| */ |
| function camelize(string) { |
| return string.replace(_hyphenPattern, function (_, character) { |
| return character.toUpperCase(); |
| }); |
| } |
| |
| module.exports = camelize; |
| },{}],149:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule camelizeStyleName |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var camelize = _dereq_(148); |
| |
| var msPattern = /^-ms-/; |
| |
| /** |
| * Camelcases a hyphenated CSS property name, for example: |
| * |
| * > camelizeStyleName('background-color') |
| * < "backgroundColor" |
| * > camelizeStyleName('-moz-transition') |
| * < "MozTransition" |
| * > camelizeStyleName('-ms-transition') |
| * < "msTransition" |
| * |
| * As Andi Smith suggests |
| * (http://www.andismith.com/blog/2012/02/modernizr-prefixed/), an `-ms` prefix |
| * is converted to lowercase `ms`. |
| * |
| * @param {string} string |
| * @return {string} |
| */ |
| function camelizeStyleName(string) { |
| return camelize(string.replace(msPattern, 'ms-')); |
| } |
| |
| module.exports = camelizeStyleName; |
| },{"148":148}],150:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule containsNode |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var isTextNode = _dereq_(163); |
| |
| /*eslint-disable no-bitwise */ |
| |
| /** |
| * Checks if a given DOM node contains or is another DOM node. |
| * |
| * @param {?DOMNode} outerNode Outer DOM node. |
| * @param {?DOMNode} innerNode Inner DOM node. |
| * @return {boolean} True if `outerNode` contains or is `innerNode`. |
| */ |
| function containsNode(_x, _x2) { |
| var _again = true; |
| |
| _function: while (_again) { |
| var outerNode = _x, |
| innerNode = _x2; |
| _again = false; |
| |
| if (!outerNode || !innerNode) { |
| return false; |
| } else if (outerNode === innerNode) { |
| return true; |
| } else if (isTextNode(outerNode)) { |
| return false; |
| } else if (isTextNode(innerNode)) { |
| _x = outerNode; |
| _x2 = innerNode.parentNode; |
| _again = true; |
| continue _function; |
| } else if (outerNode.contains) { |
| return outerNode.contains(innerNode); |
| } else if (outerNode.compareDocumentPosition) { |
| return !!(outerNode.compareDocumentPosition(innerNode) & 16); |
| } else { |
| return false; |
| } |
| } |
| } |
| |
| module.exports = containsNode; |
| },{"163":163}],151:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule createArrayFromMixed |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var toArray = _dereq_(172); |
| |
| /** |
| * 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} |
| */ |
| 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) |
| ); |
| } |
| |
| /** |
| * 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} |
| */ |
| function createArrayFromMixed(obj) { |
| if (!hasArrayNature(obj)) { |
| return [obj]; |
| } else if (Array.isArray(obj)) { |
| return obj.slice(); |
| } else { |
| return toArray(obj); |
| } |
| } |
| |
| module.exports = createArrayFromMixed; |
| },{"172":172}],152:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule createNodesFromMarkup |
| * @typechecks |
| */ |
| |
| /*eslint-disable fb-www/unsafe-html*/ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var createArrayFromMixed = _dereq_(151); |
| var getMarkupWrap = _dereq_(157); |
| var invariant = _dereq_(161); |
| |
| /** |
| * Dummy container used to render all markup. |
| */ |
| var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null; |
| |
| /** |
| * Pattern used by `getNodeName`. |
| */ |
| var nodeNamePattern = /^\s*<(\w+)/; |
| |
| /** |
| * 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. |
| */ |
| function getNodeName(markup) { |
| var nodeNameMatch = markup.match(nodeNamePattern); |
| return nodeNameMatch && nodeNameMatch[1].toLowerCase(); |
| } |
| |
| /** |
| * 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. |
| */ |
| function createNodesFromMarkup(markup, handleScript) { |
| var node = dummyNode; |
| !!!dummyNode ? "development" !== 'production' ? invariant(false, 'createNodesFromMarkup dummy not initialized') : invariant(false) : undefined; |
| 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 ? "development" !== 'production' ? invariant(false, 'createNodesFromMarkup(...): Unexpected <script> element rendered.') : invariant(false) : undefined; |
| createArrayFromMixed(scripts).forEach(handleScript); |
| } |
| |
| var nodes = createArrayFromMixed(node.childNodes); |
| while (node.lastChild) { |
| node.removeChild(node.lastChild); |
| } |
| return nodes; |
| } |
| |
| module.exports = createNodesFromMarkup; |
| },{"147":147,"151":151,"157":157,"161":161}],153:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule emptyFunction |
| */ |
| |
| "use strict"; |
| |
| function makeEmptyFunction(arg) { |
| return function () { |
| return arg; |
| }; |
| } |
| |
| /** |
| * This function accepts and discards inputs; it has no side effects. This is |
| * primarily useful idiomatically for overridable function endpoints which |
| * always need to be callable, since JS lacks a null-call idiom ala Cocoa. |
| */ |
| function emptyFunction() {} |
| |
| emptyFunction.thatReturns = makeEmptyFunction; |
| emptyFunction.thatReturnsFalse = makeEmptyFunction(false); |
| emptyFunction.thatReturnsTrue = makeEmptyFunction(true); |
| emptyFunction.thatReturnsNull = makeEmptyFunction(null); |
| emptyFunction.thatReturnsThis = function () { |
| return this; |
| }; |
| emptyFunction.thatReturnsArgument = function (arg) { |
| return arg; |
| }; |
| |
| module.exports = emptyFunction; |
| },{}],154:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule emptyObject |
| */ |
| |
| 'use strict'; |
| |
| var emptyObject = {}; |
| |
| if ("development" !== 'production') { |
| Object.freeze(emptyObject); |
| } |
| |
| module.exports = emptyObject; |
| },{}],155:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule focusNode |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * @param {DOMElement} node input/textarea to focus |
| */ |
| 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) {} |
| } |
| |
| module.exports = focusNode; |
| },{}],156:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getActiveElement |
| * @typechecks |
| */ |
| |
| /** |
| * Same as document.activeElement but wraps in a try-catch block. In IE it is |
| * not safe to call document.activeElement if there is nothing focused. |
| * |
| * The activeElement will be null only if the document or document body is not yet defined. |
| */ |
| 'use strict'; |
| |
| function getActiveElement() /*?DOMElement*/{ |
| if (typeof document === 'undefined') { |
| return null; |
| } |
| |
| try { |
| return document.activeElement || document.body; |
| } catch (e) { |
| return document.body; |
| } |
| } |
| |
| module.exports = getActiveElement; |
| },{}],157:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getMarkupWrap |
| */ |
| |
| /*eslint-disable fb-www/unsafe-html */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Dummy container used to detect which wraps are necessary. |
| */ |
| var dummyNode = ExecutionEnvironment.canUseDOM ? document.createElement('div') : null; |
| |
| /** |
| * Some browsers cannot use `innerHTML` to render certain elements standalone, |
| * so we wrap them, render the wrapped nodes, then extract the desired node. |
| * |
| * In IE8, certain elements cannot render alone, so wrap all elements ('*'). |
| */ |
| |
| var shouldWrap = {}; |
| |
| var selectWrap = [1, '<select multiple="true">', '</select>']; |
| var tableWrap = [1, '<table>', '</table>']; |
| var trWrap = [3, '<table><tbody><tr>', '</tr></tbody></table>']; |
| |
| var svgWrap = [1, '<svg xmlns="http://www.w3.org/2000/svg">', '</svg>']; |
| |
| var markupWrap = { |
| '*': [1, '?<div>', '</div>'], |
| |
| 'area': [1, '<map>', '</map>'], |
| 'col': [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'], |
| 'legend': [1, '<fieldset>', '</fieldset>'], |
| 'param': [1, '<object>', '</object>'], |
| 'tr': [2, '<table><tbody>', '</tbody></table>'], |
| |
| 'optgroup': selectWrap, |
| 'option': selectWrap, |
| |
| 'caption': tableWrap, |
| 'colgroup': tableWrap, |
| 'tbody': tableWrap, |
| 'tfoot': tableWrap, |
| 'thead': tableWrap, |
| |
| 'td': trWrap, |
| 'th': trWrap |
| }; |
| |
| // Initialize the SVG elements since we know they'll always need to be wrapped |
| // consistently. If they are created inside a <div> they will be initialized in |
| // the wrong namespace (and will not display). |
| var svgElements = ['circle', 'clipPath', 'defs', 'ellipse', 'g', 'image', 'line', 'linearGradient', 'mask', 'path', 'pattern', 'polygon', 'polyline', 'radialGradient', 'rect', 'stop', 'text', 'tspan']; |
| svgElements.forEach(function (nodeName) { |
| markupWrap[nodeName] = svgWrap; |
| shouldWrap[nodeName] = true; |
| }); |
| |
| /** |
| * 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. |
| */ |
| function getMarkupWrap(nodeName) { |
| !!!dummyNode ? "development" !== 'production' ? invariant(false, 'Markup wrapping node not initialized') : invariant(false) : undefined; |
| 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; |
| } |
| |
| module.exports = getMarkupWrap; |
| },{"147":147,"161":161}],158:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule getUnboundedScrollPosition |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * 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. |
| */ |
| 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 |
| }; |
| } |
| |
| module.exports = getUnboundedScrollPosition; |
| },{}],159:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule hyphenate |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var _uppercasePattern = /([A-Z])/g; |
| |
| /** |
| * 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} |
| */ |
| function hyphenate(string) { |
| return string.replace(_uppercasePattern, '-$1').toLowerCase(); |
| } |
| |
| module.exports = hyphenate; |
| },{}],160:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule hyphenateStyleName |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var hyphenate = _dereq_(159); |
| |
| var 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} |
| */ |
| function hyphenateStyleName(string) { |
| return hyphenate(string).replace(msPattern, '-ms-'); |
| } |
| |
| module.exports = hyphenateStyleName; |
| },{"159":159}],161:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule invariant |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Use invariant() to assert state which your program assumes to be true. |
| * |
| * Provide sprintf-style format (only %s is supported) and arguments |
| * to provide information about what broke and what you were |
| * expecting. |
| * |
| * The invariant message will be stripped in production, but the invariant |
| * will remain to ensure logic does not differ in production. |
| */ |
| |
| var invariant = function (condition, format, a, b, c, d, e, f) { |
| if ("development" !== 'production') { |
| if (format === undefined) { |
| throw new Error('invariant requires an error message argument'); |
| } |
| } |
| |
| if (!condition) { |
| var error; |
| if (format === undefined) { |
| error = new Error('Minified exception occurred; use the non-minified dev environment ' + 'for the full error message and additional helpful warnings.'); |
| } else { |
| var args = [a, b, c, d, e, f]; |
| var argIndex = 0; |
| error = new Error('Invariant Violation: ' + format.replace(/%s/g, function () { |
| return args[argIndex++]; |
| })); |
| } |
| |
| error.framesToPop = 1; // we don't care about invariant's own frame |
| throw error; |
| } |
| }; |
| |
| module.exports = invariant; |
| },{}],162:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule isNode |
| * @typechecks |
| */ |
| |
| /** |
| * @param {*} object The object to check. |
| * @return {boolean} Whether or not the object is a DOM node. |
| */ |
| 'use strict'; |
| |
| function isNode(object) { |
| return !!(object && (typeof Node === 'function' ? object instanceof Node : typeof object === 'object' && typeof object.nodeType === 'number' && typeof object.nodeName === 'string')); |
| } |
| |
| module.exports = isNode; |
| },{}],163:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule isTextNode |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var isNode = _dereq_(162); |
| |
| /** |
| * @param {*} object The object to check. |
| * @return {boolean} Whether or not the object is a DOM text node. |
| */ |
| function isTextNode(object) { |
| return isNode(object) && object.nodeType == 3; |
| } |
| |
| module.exports = isTextNode; |
| },{"162":162}],164:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule joinClasses |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Combines multiple className strings into one. |
| * http://jsperf.com/joinclasses-args-vs-array |
| * |
| * @param {...?string} className |
| * @return {string} |
| */ |
| function joinClasses(className /*, ... */) { |
| if (!className) { |
| className = ''; |
| } |
| var nextClass; |
| var argLength = arguments.length; |
| if (argLength > 1) { |
| for (var ii = 1; ii < argLength; ii++) { |
| nextClass = arguments[ii]; |
| if (nextClass) { |
| className = (className ? className + ' ' : '') + nextClass; |
| } |
| } |
| } |
| return className; |
| } |
| |
| module.exports = joinClasses; |
| },{}],165:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule keyMirror |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * Constructs an enumeration with keys equal to their value. |
| * |
| * For example: |
| * |
| * var COLORS = keyMirror({blue: null, red: null}); |
| * var myColor = COLORS.blue; |
| * var isColorValid = !!COLORS[myColor]; |
| * |
| * The last line could not be performed if the values of the generated enum were |
| * not equal to their keys. |
| * |
| * Input: {key1: val1, key2: val2} |
| * Output: {key1: key1, key2: key2} |
| * |
| * @param {object} obj |
| * @return {object} |
| */ |
| var keyMirror = function (obj) { |
| var ret = {}; |
| var key; |
| !(obj instanceof Object && !Array.isArray(obj)) ? "development" !== 'production' ? invariant(false, 'keyMirror(...): Argument must be an object.') : invariant(false) : undefined; |
| for (key in obj) { |
| if (!obj.hasOwnProperty(key)) { |
| continue; |
| } |
| ret[key] = key; |
| } |
| return ret; |
| }; |
| |
| module.exports = keyMirror; |
| },{"161":161}],166:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule keyOf |
| */ |
| |
| /** |
| * Allows extraction of a minified key. Let's the build system minify keys |
| * without losing the ability to dynamically use key strings as values |
| * themselves. Pass in an object with a single key/val pair and it will return |
| * you the string key of that single record. Suppose you want to grab the |
| * value for a key 'className' inside of an object. Key/val minification may |
| * have aliased that key to be 'xa12'. keyOf({className: null}) will return |
| * 'xa12' in that case. Resolve keys you want to use once at startup time, then |
| * reuse those resolutions. |
| */ |
| "use strict"; |
| |
| var keyOf = function (oneKeyObj) { |
| var key; |
| for (key in oneKeyObj) { |
| if (!oneKeyObj.hasOwnProperty(key)) { |
| continue; |
| } |
| return key; |
| } |
| return null; |
| }; |
| |
| module.exports = keyOf; |
| },{}],167:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule mapObject |
| */ |
| |
| 'use strict'; |
| |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| |
| /** |
| * Executes the provided `callback` once for each enumerable own property in the |
| * object and constructs a new object from the results. The `callback` is |
| * invoked with three arguments: |
| * |
| * - the property value |
| * - the property name |
| * - the object being traversed |
| * |
| * Properties that are added after the call to `mapObject` will not be visited |
| * by `callback`. If the values of existing properties are changed, the value |
| * passed to `callback` will be the value at the time `mapObject` visits them. |
| * Properties that are deleted before being visited are not visited. |
| * |
| * @grep function objectMap() |
| * @grep function objMap() |
| * |
| * @param {?object} object |
| * @param {function} callback |
| * @param {*} context |
| * @return {?object} |
| */ |
| function mapObject(object, callback, context) { |
| if (!object) { |
| return null; |
| } |
| var result = {}; |
| for (var name in object) { |
| if (hasOwnProperty.call(object, name)) { |
| result[name] = callback.call(context, object[name], name, object); |
| } |
| } |
| return result; |
| } |
| |
| module.exports = mapObject; |
| },{}],168:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule memoizeStringOnly |
| * @typechecks static-only |
| */ |
| |
| 'use strict'; |
| |
| /** |
| * Memoizes the return value of a function that accepts one string argument. |
| * |
| * @param {function} callback |
| * @return {function} |
| */ |
| function memoizeStringOnly(callback) { |
| var cache = {}; |
| return function (string) { |
| if (!cache.hasOwnProperty(string)) { |
| cache[string] = callback.call(this, string); |
| } |
| return cache[string]; |
| }; |
| } |
| |
| module.exports = memoizeStringOnly; |
| },{}],169:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule performance |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var ExecutionEnvironment = _dereq_(147); |
| |
| var performance; |
| |
| if (ExecutionEnvironment.canUseDOM) { |
| performance = window.performance || window.msPerformance || window.webkitPerformance; |
| } |
| |
| module.exports = performance || {}; |
| },{"147":147}],170:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule performanceNow |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var performance = _dereq_(169); |
| var curPerformance = performance; |
| |
| /** |
| * Detect if we can use `window.performance.now()` and gracefully fallback to |
| * `Date.now()` if it doesn't exist. We need to support Firefox < 15 for now |
| * because of Facebook's testing infrastructure. |
| */ |
| if (!curPerformance || !curPerformance.now) { |
| curPerformance = Date; |
| } |
| |
| var performanceNow = curPerformance.now.bind(curPerformance); |
| |
| module.exports = performanceNow; |
| },{"169":169}],171:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule shallowEqual |
| * @typechecks |
| * |
| */ |
| |
| 'use strict'; |
| |
| var hasOwnProperty = Object.prototype.hasOwnProperty; |
| |
| /** |
| * 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. |
| */ |
| function shallowEqual(objA, objB) { |
| if (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. |
| var bHasOwnProperty = hasOwnProperty.bind(objB); |
| for (var i = 0; i < keysA.length; i++) { |
| if (!bHasOwnProperty(keysA[i]) || objA[keysA[i]] !== objB[keysA[i]]) { |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| module.exports = shallowEqual; |
| },{}],172:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule toArray |
| * @typechecks |
| */ |
| |
| 'use strict'; |
| |
| var invariant = _dereq_(161); |
| |
| /** |
| * 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} |
| */ |
| function toArray(obj) { |
| var length = obj.length; |
| |
| // Some browse builtin objects can report typeof 'function' (e.g. NodeList in |
| // old versions of Safari). |
| !(!Array.isArray(obj) && (typeof obj === 'object' || typeof obj === 'function')) ? "development" !== 'production' ? invariant(false, 'toArray: Array-like object expected') : invariant(false) : undefined; |
| |
| !(typeof length === 'number') ? "development" !== 'production' ? invariant(false, 'toArray: Object needs a length property') : invariant(false) : undefined; |
| |
| !(length === 0 || length - 1 in obj) ? "development" !== 'production' ? invariant(false, 'toArray: Object should have keys for indices') : invariant(false) : undefined; |
| |
| // 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; |
| } |
| |
| module.exports = toArray; |
| },{"161":161}],173:[function(_dereq_,module,exports){ |
| /** |
| * Copyright 2014-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| * @providesModule warning |
| */ |
| |
| 'use strict'; |
| |
| var emptyFunction = _dereq_(153); |
| |
| /** |
| * Similar to invariant but only logs a warning if the condition is not met. |
| * This can be used to log issues in development environments in critical |
| * paths. Removing the logging code for production environments will keep the |
| * same logic and follow the same code paths. |
| */ |
| |
| var warning = emptyFunction; |
| |
| if ("development" !== 'production') { |
| warning = function (condition, format) { |
| for (var _len = arguments.length, args = Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { |
| args[_key - 2] = arguments[_key]; |
| } |
| |
| if (format === undefined) { |
| throw new Error('`warning(condition, format, ...args)` requires a warning ' + 'message argument'); |
| } |
| |
| if (format.indexOf('Failed Composite propType: ') === 0) { |
| return; // Ignore CompositeComponent proptype check. |
| } |
| |
| if (!condition) { |
| var argIndex = 0; |
| var message = 'Warning: ' + format.replace(/%s/g, function () { |
| return args[argIndex++]; |
| }); |
| if (typeof console !== 'undefined') { |
| console.error(message); |
| } |
| try { |
| // --- Welcome to debugging React --- |
| // This error was thrown as a convenience so that you can use this stack |
| // to find the callsite that caused this warning to fire. |
| throw new Error(message); |
| } catch (x) {} |
| } |
| }; |
| } |
| |
| module.exports = warning; |
| },{"153":153}]},{},[1])(1) |
| }); |
| |
| 'use strict'; |
| |
| var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); |
| |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } |
| |
| function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
| |
| var ContextMenu = (function (_React$Component) { |
| _inherits(ContextMenu, _React$Component); |
| |
| function ContextMenu(props) { |
| _classCallCheck(this, ContextMenu); |
| |
| _React$Component.call(this, props); |
| } |
| |
| ContextMenu.prototype.componentWillMount = function componentWillMount() { |
| var _this = this; |
| var mount_point; |
| $('body').on('click.contextMenu', function (evt) { |
| if ($(evt.target).is(':not(.contextMenu)')) { |
| if ($(evt.target).is('.config-tool')) { |
| mount_point = $(evt.target).next().data('mount-point'); |
| } else { |
| mount_point = ""; |
| } |
| _this.props.onOptionClick(mount_point); |
| } |
| }); |
| }; |
| |
| ContextMenu.prototype.componentWillUnmount = function componentWillUnmount() { |
| $("body").off('click.contextMenu'); |
| }; |
| |
| ContextMenu.prototype.render = function render() { |
| var _this = this; |
| return React.createElement( |
| 'div', |
| { className: 'contextMenu' }, |
| React.createElement( |
| 'ul', |
| null, |
| this.props.items.map(function (o, i) { |
| return React.createElement( |
| 'li', |
| { key: i }, |
| React.createElement(ToolTipLink, { |
| href: o.href, |
| classes: _this.props.classes.concat([o.className]), |
| toolTip: o.tooltip, |
| text: o.text }) |
| ); |
| }) |
| ) |
| ); |
| }; |
| |
| _createClass(ContextMenu, null, [{ |
| key: 'propTypes', |
| value: { |
| classes: React.PropTypes.array.isRequired, |
| items: React.PropTypes.arrayOf(React.PropTypes.object).isRequired, |
| onOptionClick: React.PropTypes.func.isRequired |
| }, |
| enumerable: true |
| }, { |
| key: 'defaultOptions', |
| value: { |
| classes: [] |
| }, |
| enumerable: true |
| }]); |
| |
| return ContextMenu; |
| })(React.Component); |
| |
| /* |
| * $ lightbox_me |
| * By: Buck Wilson |
| * Version : 2.3 |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| |
| (function($) { |
| |
| $.fn.lightbox_me = function(options) { |
| |
| return this.each(function() { |
| |
| var |
| opts = $.extend({}, $.fn.lightbox_me.defaults, options), |
| $overlay = $(), |
| $self = $(this), |
| $iframe = $('<iframe />', {style: 'z-index: ' + (opts.zIndex + 1) + ';border: none; margin: 0; padding: 0; position: absolute; width: 100%; height: 100%; top: 0; left: 0; filter: mask();'}); |
| ie6 = ($.browser.msie && $.browser.version < 7); |
| |
| if (opts.showOverlay) { |
| //check if there's an existing overlay, if so, make subequent ones clear |
| var $currentOverlays = $(".js_lb_overlay:visible"); |
| if ($currentOverlays.length > 0){ |
| $overlay = $('<div/>', {'class': 'lb_overlay_clear js_lb_overlay'}); |
| } else { |
| $overlay = $('<div/>', {'class': opts.classPrefix + '_overlay js_lb_overlay'}); |
| } |
| } |
| |
| /*---------------------------------------------------- |
| DOM Building |
| ---------------------------------------------------- */ |
| if (ie6) { |
| var src = /^https/i.test(window.location.href || '') ? 'javascript:false' : 'about:blank'; |
| $iframe.attr('src', src); |
| $('body').append($iframe); |
| } // iframe shim for ie6, to hide select elements |
| $('body').append($self.hide()).append($overlay); |
| |
| |
| /*---------------------------------------------------- |
| Overlay CSS stuffs |
| ---------------------------------------------------- */ |
| |
| // set css of the overlay |
| if (opts.showOverlay) { |
| setOverlayHeight(); // pulled this into a function because it is called on window resize. |
| $overlay.css({ position: 'absolute', width: '100%', top: 0, left: 0, right: 0, bottom: 0, zIndex: (opts.zIndex + 2), display: 'none' }); |
| if (!$overlay.hasClass('lb_overlay_clear')){ |
| $overlay.css(opts.overlayCSS); |
| } |
| } |
| |
| /*---------------------------------------------------- |
| Animate it in. |
| ---------------------------------------------------- */ |
| // |
| if (opts.showOverlay) { |
| $overlay.fadeIn(opts.overlaySpeed, function() { |
| setSelfPosition(); |
| $self[opts.appearEffect](opts.lightboxSpeed, function() { setOverlayHeight(); setSelfPosition(); opts.onLoad()}); |
| }); |
| } else { |
| setSelfPosition(); |
| $self[opts.appearEffect](opts.lightboxSpeed, function() { opts.onLoad()}); |
| } |
| |
| /*---------------------------------------------------- |
| Hide parent if parent specified (parentLightbox should be jquery reference to any parent lightbox) |
| ---------------------------------------------------- */ |
| if (opts.parentLightbox) { |
| opts.parentLightbox.fadeOut(200); |
| } |
| |
| |
| /*---------------------------------------------------- |
| Bind Events |
| ---------------------------------------------------- */ |
| |
| $(window).resize(setOverlayHeight) |
| .resize(setSelfPosition) |
| .scroll(setSelfPosition); |
| |
| $(window).bind('keyup.lightbox_me', observeKeyPress); |
| |
| if (opts.closeClick) { |
| $overlay.click(function(e) { closeLightbox(); e.preventDefault; }); |
| } |
| $self.delegate(opts.closeSelector, "click", function(e) { |
| closeLightbox(); e.preventDefault(); |
| }); |
| $self.bind('close', closeLightbox); |
| $self.bind('reposition', setSelfPosition); |
| |
| |
| |
| /*-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- */ |
| |
| |
| /*---------------------------------------------------- |
| Private Functions |
| ---------------------------------------------------- */ |
| |
| /* Remove or hide all elements */ |
| function closeLightbox() { |
| var s = $self[0].style; |
| if (opts.destroyOnClose) { |
| $self.add($overlay).remove(); |
| } else { |
| $self.add($overlay).hide(); |
| } |
| |
| //show the hidden parent lightbox |
| if (opts.parentLightbox) { |
| opts.parentLightbox.fadeIn(200); |
| } |
| |
| $iframe.remove(); |
| |
| // clean up events. |
| $self.undelegate(opts.closeSelector, "click"); |
| |
| $(window).unbind('reposition', setOverlayHeight); |
| $(window).unbind('reposition', setSelfPosition); |
| $(window).unbind('scroll', setSelfPosition); |
| $(window).unbind('keyup.lightbox_me'); |
| if (ie6) |
| s.removeExpression('top'); |
| opts.onClose(); |
| } |
| |
| |
| /* Function to bind to the window to observe the escape/enter key press */ |
| function observeKeyPress(e) { |
| if((e.keyCode == 27 || (e.DOM_VK_ESCAPE == 27 && e.which==0)) && opts.closeEsc) closeLightbox(); |
| } |
| |
| |
| /* Set the height of the overlay |
| : if the document height is taller than the window, then set the overlay height to the document height. |
| : otherwise, just set overlay height: 100% |
| */ |
| function setOverlayHeight() { |
| if ($(window).height() < $(document).height()) { |
| $overlay.css({height: $(document).height() + 'px'}); |
| $iframe.css({height: $(document).height() + 'px'}); |
| } else { |
| $overlay.css({height: '100%'}); |
| if (ie6) { |
| $('html,body').css('height','100%'); |
| $iframe.css('height', '100%'); |
| } // ie6 hack for height: 100%; TODO: handle this in IE7 |
| } |
| } |
| |
| |
| /* Set the position of the modal'd window ($self) |
| : if $self is taller than the window, then make it absolutely positioned |
| : otherwise fixed |
| */ |
| function setSelfPosition() { |
| var s = $self[0].style; |
| |
| // reset CSS so width is re-calculated for margin-left CSS |
| $self.css({left: '50%', marginLeft: ($self.outerWidth() / 2) * -1, zIndex: (opts.zIndex + 3) }); |
| |
| |
| /* we have to get a little fancy when dealing with height, because lightbox_me |
| is just so fancy. |
| */ |
| |
| // if the height of $self is bigger than the window and self isn't already position absolute |
| if (($self.height() + 80 >= $(window).height()) && ($self.css('position') != 'absolute' || ie6)) { |
| |
| // we are going to make it positioned where the user can see it, but they can still scroll |
| // so the top offset is based on the user's scroll position. |
| var topOffset = $(document).scrollTop() + 40; |
| $self.css({position: 'absolute', top: topOffset + 'px', marginTop: 0}) |
| if (ie6) { |
| s.removeExpression('top'); |
| } |
| } else if ($self.height()+ 80 < $(window).height()) { |
| //if the height is less than the window height, then we're gonna make this thing position: fixed. |
| // in ie6 we're gonna fake it. |
| if (ie6) { |
| s.position = 'absolute'; |
| if (opts.centered) { |
| s.setExpression('top', '(document.documentElement.clientHeight || document.body.clientHeight) / 2 - (this.offsetHeight / 2) + (blah = document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop) + "px"') |
| s.marginTop = 0; |
| } else { |
| var top = (opts.modalCSS && opts.modalCSS.top) ? parseInt(opts.modalCSS.top) : 0; |
| s.setExpression('top', '((blah = document.documentElement.scrollTop ? document.documentElement.scrollTop : document.body.scrollTop) + '+top+') + "px"') |
| } |
| } else { |
| if (opts.centered) { |
| $self.css({ position: 'fixed', top: '50%', marginTop: ($self.outerHeight() / 2) * -1}) |
| } else { |
| $self.css({ position: 'fixed'}).css(opts.modalCSS); |
| } |
| |
| } |
| } |
| } |
| |
| }); |
| |
| |
| |
| }; |
| |
| $.fn.lightbox_me.defaults = { |
| |
| // animation |
| appearEffect: "fadeIn", |
| appearEase: "", |
| overlaySpeed: 250, |
| lightboxSpeed: 300, |
| |
| // close |
| closeSelector: ".close", |
| closeClick: true, |
| closeEsc: true, |
| |
| // behavior |
| destroyOnClose: false, |
| showOverlay: true, |
| parentLightbox: false, |
| |
| // callbacks |
| onLoad: function() {}, |
| onClose: function() {}, |
| |
| // style |
| classPrefix: 'lb', |
| zIndex: 999, |
| centered: false, |
| modalCSS: {top: '40px'}, |
| overlayCSS: {background: 'black', opacity: .3} |
| } |
| })(jQuery); |
| |
| /* |
| Licensed to the Apache Software Foundation (ASF) under one |
| or more contributor license agreements. See the NOTICE file |
| distributed with this work for additional information |
| regarding copyright ownership. The ASF licenses this file |
| to you under the Apache License, Version 2.0 (the |
| "License"); you may not use this file except in compliance |
| with the License. You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, |
| software distributed under the License is distributed on an |
| "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| KIND, either express or implied. See the License for the |
| specific language governing permissions and limitations |
| under the License. |
| */ |
| |
| // This logic is the same as the inline JS from the Lightbox widget |
| function startLightbox($lightbox) { |
| $lightbox.lightbox_me(); |
| $lightbox.on('click', '.close', function (e) { |
| e.preventDefault(); |
| $lightbox.trigger('close'); |
| }); |
| return $lightbox; |
| } |
| |
| $(function() { |
| $('body').on('click', 'a.admin_modal', function(e) { |
| e.preventDefault(); |
| |
| $('#lightbox_admin_modal').remove(); |
| $('body').append('<div id="lightbox_admin_modal" class="modal" style="display:none"> \ |
| <a class="icon close" href="#" title="Close"><i class="fa fa-close"></i></a> \ |
| <h1 id="admin_modal_title"></h1><div id="admin_modal_contents">Loading...</div> \ |
| </div>'); |
| |
| startLightbox($('#lightbox_admin_modal')); |
| |
| var link = this; |
| $.get(link.href, function(data) { |
| var $popup_title = $('#admin_modal_title'); |
| var $popup_contents = $('#admin_modal_contents'); |
| $popup_title.html($(link).html()); |
| $popup_contents.html(data); |
| var csrf_exists = $popup_contents.find('form > input[name="_session_id"]').length; |
| if (!csrf_exists) { |
| var cval = $.cookie('_session_id'); |
| var csrf_input = $('<input name="_session_id" type="hidden" value="'+cval+'">'); |
| $popup_contents.find('form').append(csrf_input); |
| } |
| }); |
| }); |
| }); |
| |
| /** |
| * ReactDOM v0.14.1 |
| * |
| * Copyright 2013-2015, Facebook, Inc. |
| * All rights reserved. |
| * |
| * This source code is licensed under the BSD-style license found in the |
| * LICENSE file in the root directory of this source tree. An additional grant |
| * of patent rights can be found in the PATENTS file in the same directory. |
| * |
| */ |
| // Based off https://github.com/ForbesLindesay/umd/blob/master/template.js |
| ;(function(f) { |
| // CommonJS |
| if (typeof exports === "object" && typeof module !== "undefined") { |
| module.exports = f(require('react')); |
| |
| // RequireJS |
| } else if (typeof define === "function" && define.amd) { |
| define(['react'], f); |
| |
| // <script> |
| } else { |
| var g |
| if (typeof window !== "undefined") { |
| g = window; |
| } else if (typeof global !== "undefined") { |
| g = global; |
| } else if (typeof self !== "undefined") { |
| g = self; |
| } else { |
| // works providing we're not in "use strict"; |
| // needed for Java 8 Nashorn |
| // see https://github.com/facebook/react/issues/3037 |
| g = this; |
| } |
| g.ReactDOM = f(g.React); |
| } |
| |
| })(function(React) { |
| return React.__SECRET_DOM_DO_NOT_USE_OR_YOU_WILL_BE_FIRED; |
| }); |
| |
| !function(t){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=t();else if("function"==typeof define&&define.amd)define([],t);else{var e;e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,e.ReactDrag=t()}}(function(){return function t(e,n,r){function o(s,i){if(!n[s]){if(!e[s]){var p="function"==typeof require&&require;if(!i&&p)return p(s,!0);if(a)return a(s,!0);var f=new Error("Cannot find module '"+s+"'");throw f.code="MODULE_NOT_FOUND",f}var u=n[s]={exports:{}};e[s][0].call(u.exports,function(t){var n=e[s][1][t];return o(n?n:t)},u,u.exports,t,e,n,r)}return n[s].exports}for(var a="function"==typeof require&&require,s=0;s<r.length;s++)o(r[s]);return o}({1:[function(t,e,n){(function(t){"use strict";function n(){for(var t="",e=0;e<arguments.length;e++){var r=arguments[e];if(r){var o=typeof r;if("string"===o||"number"===o)t+=" "+r;else if(Array.isArray(r))t+=" "+n.apply(null,r);else if("object"===o)for(var a in r)r.hasOwnProperty(a)&&r[a]&&(t+=" "+a)}}return t.substr(1)}function r(t){return{position:{top:t.state.pageY,left:t.state.pageX}}}function o(t){return"both"===t.props.axis||"y"===t.props.axis}function a(t){return"both"===t.props.axis||"x"===t.props.axis}function s(t){return"function"==typeof t||"[object Function]"===Object.prototype.toString.call(t)}function i(t,e){for(var n=0,r=t.length,o=null;r>n;n+=1)if(o=t[n],e.apply(e,[o,n,t]))return o}function p(t,e){var n=i(["matches","webkitMatchesSelector","mozMatchesSelector","msMatchesSelector","oMatchesSelector"],function(e){return s(t[e])});return t[n].call(t,e)}function f(t){var e=t.touches&&t.touches[0]||t;return{pageX:e.pageX,pageY:e.pageY}}function u(t,e,n,r){if(n){"string"!=typeof n&&"parent"!==n.toLowerCase()&&"object"!=typeof n&&console.warn('Bound should either "parent" or an object');var o=r.parentNode,a=n.top||0,s=n.left||0,i=n.right||o.offsetWidth,p=n.bottom||o.offsetHeight;t=Math.min(t,i-r.offsetWidth),e=Math.min(e,p-r.offsetHeight),t=Math.max(s,t),e=Math.max(a,e)}return{pageX:t,pageY:e}}function h(t,e,n){t&&(t.attachEvent?t.attachEvent("on"+e,n):t.addEventListener?t.addEventListener(e,n,!0):t["on"+e]=n)}function d(t,e,n){t&&(t.detachEvent?t.detachEvent("on"+e,n):t.removeEventListener?t.removeEventListener(e,n,!0):t["on"+e]=null)}var c="undefined"!=typeof window?window.React:"undefined"!=typeof t?t.React:null,l=("undefined"!=typeof window?window.ReactDOM:"undefined"!=typeof t?t.ReactDOM:null).findDOMNode,g=function(){},y=n;if("undefined"==typeof window)var v=!1;else{var v="ontouchstart"in window||"onmsgesturechange"in window;try{document.createEvent("TouchEvent")}catch(w){v=!1}}var m=function(){var t={touch:{start:"touchstart",move:"touchmove",end:"touchend"},mouse:{start:"mousedown",move:"mousemove",end:"mouseup"}};return t[v?"touch":"mouse"]}(),D=c.createClass({displayName:"Draggable",propTypes:{axis:c.PropTypes.oneOf(["both","x","y"]),handle:c.PropTypes.string,cancel:c.PropTypes.string,grid:c.PropTypes.arrayOf(c.PropTypes.number),start:c.PropTypes.object,onStart:c.PropTypes.func,onDrag:c.PropTypes.func,onStop:c.PropTypes.func,onMouseDown:c.PropTypes.func,bound:c.PropTypes.any},componentWillUnmount:function(){d(window,m.move,this.handleDrag),d(window,m.end,this.handleDragEnd)},getDefaultProps:function(){return{axis:"both",handle:null,cancel:null,grid:null,bound:!1,start:{x:0,y:0},onStart:g,onDrag:g,onStop:g,onMouseDown:g}},getInitialState:function(){return{dragging:!1,startX:0,startY:0,offsetX:0,offsetY:0,pageX:this.props.start.x,pageY:this.props.start.y}},handleDragStart:function(t){this.props.onMouseDown(t);var e=l(this);if(!(this.props.handle&&!p(t.target,this.props.handle)||this.props.cancel&&p(t.target,this.props.cancel))){var n=f(t);this.setState({dragging:!0,offsetX:parseInt(n.pageX,10),offsetY:parseInt(n.pageY,10),startX:parseInt(e.style.left,10)||0,startY:parseInt(e.style.top,10)||0}),this.props.onStart(t,r(this)),h(window,m.move,this.handleDrag),h(window,m.end,this.handleDragEnd)}},handleDragEnd:function(t){this.state.dragging&&(this.setState({dragging:!1}),this.props.onStop(t,r(this)),d(window,m.move,this.handleDrag),d(window,m.end,this.handleDragEnd))},handleDrag:function(t){var e=f(t),n=this.state.startX+(e.pageX-this.state.offsetX),o=this.state.startY+(e.pageY-this.state.offsetY),a=u(n,o,this.props.bound,l(this));if(n=a.pageX,o=a.pageY,Array.isArray(this.props.grid)){var s=n<parseInt(this.state.pageX,10)?-1:1,i=o<parseInt(this.state.pageY,10)?-1:1;n=Math.abs(n-parseInt(this.state.pageX,10))>=this.props.grid[0]?parseInt(this.state.pageX,10)+this.props.grid[0]*s:this.state.pageX,o=Math.abs(o-parseInt(this.state.pageY,10))>=this.props.grid[1]?parseInt(this.state.pageY,10)+this.props.grid[1]*i:this.state.pageY}this.setState({pageX:n,pageY:o}),this.props.onDrag(t,r(this)),t.preventDefault()},render:function(){var t={top:o(this)?this.state.pageY:this.state.startY,left:a(this)?this.state.pageX:this.state.startX},e=y({"react-drag":!0,"react-drag-dragging":this.state.dragging}),n=this.props.children.props.className;return n&&(e=n+" "+e),c.cloneElement(c.Children.only(this.props.children),{style:t,className:e,onMouseDown:this.handleDragStart,onTouchStart:function(t){return t.preventDefault(),this.handleDragStart.apply(this,arguments)}.bind(this),onMouseUp:this.handleDragEnd,onTouchEnd:this.handleDragEnd})}});e.exports=D}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[1])(1)}); |
| !function(e){if("object"==typeof exports&&"undefined"!=typeof module)module.exports=e();else if("function"==typeof define&&define.amd)define([],e);else{var t;t="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:this,t.ReactReorderable=e()}}(function(){return function e(t,n,r){function o(a,s){if(!n[a]){if(!t[a]){var l="function"==typeof require&&require;if(!s&&l)return l(a,!0);if(i)return i(a,!0);var u=new Error("Cannot find module '"+a+"'");throw u.code="MODULE_NOT_FOUND",u}var c=n[a]={exports:{}};t[a][0].call(c.exports,function(e){var n=t[a][1][e];return o(n?n:e)},c,c.exports,e,t,n,r)}return n[a].exports}for(var i="function"==typeof require&&require,a=0;a<r.length;a++)o(r[a]);return o}({1:[function(e,t,n){(function(e){"use strict";function n(e){for(;e;){if(e.className&&e.className.indexOf("react-reorderable-item")>=0)return e;e=e.parentNode}return null}function r(e){var t=e.touches&&e.touches[0]||e;return{clientX:t.clientX,clientY:t.clientY}}function o(e,t){var n=t.getBoundingClientRect(),o=n.top,i=n.left,a=n.width,s=n.height,l=r(e);return l.clientY<o||l.clientY>o+s?p.NONE:l.clientX>i&&l.clientX<i+.5*a?p.NEXT:l.clientX>i+.5*a&&l.clientX<i+a?p.PREVIOUS:p.NONE}function i(e,t){var n=t.getBoundingClientRect(),o=n.top,i=n.left,a=n.width,s=n.height,l=r(e);return l.clientX<i||l.clientX>i+a?p.NONE:l.clientY>o&&l.clientY<o+.5*s?p.NEXT:l.clientY>o+.5*s&&l.clientY<o+s?p.PREVIOUS:p.NONE}function a(e,t,n){var r,a=t.parentNode,s=a.children,l=!1,u={};n=n||"list";for(var c=0;c<s.length&&!l;c+=1)if(r=s[c],r.getAttribute("data-reorderable-key")!==t.getAttribute("data-reorderable-key")){var d;if(d="list"===n?i(e,r):o(e,r),d!==p.NONE)return u.node=r,u.type=d,u}return u}function s(e){for(var t,n="node-",r={},o=[],i=0;i<e.length;i+=1){var t=n+(i+1);o.push(t),e[i]=c.createElement("div",{className:"react-reorderable-item",key:t,"data-reorderable-key":t},e[i]),r[t]=e[i]}return{map:r,ids:o}}function l(e,t){for(var n=e.parentNode.querySelectorAll(t),r=0;r<n.length;r+=1)if(e===n[r])return!0;return!1}function u(e,t,n){var r=e.getAttribute("data-reorderable-key"),o=n.indexOf(r);n.splice(o,1);var i=t.node.getAttribute("data-reorderable-key"),a=n.indexOf(i);return t.type===p.PREVIOUS?n.splice(a+1,0,r):n.splice(a,0,r),n}var c="undefined"!=typeof window?window.React:"undefined"!=typeof e?e.React:null,d=("undefined"!=typeof window?window.ReactDOM:"undefined"!=typeof e?e.ReactDOM:null).findDOMNode,f="undefined"!=typeof window?window.ReactDrag:"undefined"!=typeof e?e.ReactDrag:null,p={NONE:0,NEXT:1,PREVIOUS:2},h=c.createClass({componentWillMount:function(){window.addEventListener("mouseup",this._mouseupHandler=function(){this.setState({mouseDownPosition:null})}.bind(this))},componentWillUnmount:function(){window.removeEventListener("mouseup",this._mouseupHandler)},componentWillReceiveProps:function(e){if(e.children){var t=s(e.children);this.setState({order:t.ids,reorderableMap:t.map})}},getInitialState:function(){var e=s(this.props.children);return{order:e.ids,startPosition:null,activeItem:null,reorderableMap:e.map}},onDragStop:function(e){this.setState({activeItem:null,startPosition:null}),this.props.onDrop(this.state.order.map(function(e){return this.state.reorderableMap[e].props.children},this))},onDrag:function(e){var t=d(this.refs.handle),r=a(e,t,this.props.mode);if(r&&r.node){for(var o=this.state.order.slice(),i=u(n(t),r,this.state.order),s=!1,l=0;l<i.length&&!s;l+=1)i[l]!==o[l]&&(s=!0);s&&this.props.onChange(this.state.order.map(function(e){return this.state.reorderableMap[e].props.children},this)),this.setState({order:i})}},onMouseDown:function(e){var t;(!this.props.handle||l(e.target,this.props.handle))&&(t=r(e),this.setState({mouseDownPosition:{x:t.clientX,y:t.clientY}}))},onTouchStart:function(e){e.preventDefault(),this.onMouseDown(e)},onMouseMove:function(e){var t;if(!this.state.activeItem){var o=this.state.mouseDownPosition;if(!o)return;if(t=r(e),Math.abs(t.clientX-o.x)>=5||Math.abs(t.clientY-o.y)>=5){var i=n(e.target),a=e.nativeEvent,s=i.getAttribute("data-reorderable-key");this.props.onDragStart(this.state.reorderableMap[s]),this.activeItem=i;var l=i.parentNode&&i.parentNode.parentNode;this.setState({mouseDownPosition:null,activeItem:s,startPosition:{x:i.offsetLeft-(l&&l.scrollLeft||0),y:i.offsetTop-(l&&l.scrollTop||0)}},function(){this.refs.handle.handleDragStart(a)}.bind(this))}}},render:function(){var e,t=this.state.order.map(function(e){var t=this.state.activeItem?"noselect ":"";this.state.activeItem===e&&(t+="react-reorderable-item-active");var n=this.state.reorderableMap[e].props.className||"";return n&&(t=n+" "+t),c.cloneElement(this.state.reorderableMap[e],{key:"reaorderable-"+e,ref:"active",onMouseDown:this.onMouseDown,onMouseMove:this.onMouseMove,onTouchStart:this.onTouchStart,onTouchMove:this.onMouseMove,className:t})},this);if(this.state.activeItem){var n=this.state.startPosition,r="react-reorderable-handle",o=this.state.reorderableMap[this.state.activeItem].props.className||"";o&&(r=o+" "+r),e=c.cloneElement(this.state.reorderableMap[this.state.activeItem],{className:r}),e=c.createElement(f,{onStop:this.onDragStop,onDrag:this.onDrag,ref:"handle",start:{x:n.x,y:n.y}},e)}return c.createElement("div",{ref:"wrapper"},t,e)}});h.propTypes={onDragStart:c.PropTypes.func,onDrag:c.PropTypes.func,onDrop:c.PropTypes.func,onChange:c.PropTypes.func},h.defaultProps={onDragStart:function(){},onDrag:function(){},onDrop:function(){},onChange:function(){}},t.exports=h}).call(this,"undefined"!=typeof global?global:"undefined"!=typeof self?self:"undefined"!=typeof window?window:{})},{}]},{},[1])(1)}); |
| // Underscore.js 1.8.3 |
| // http://underscorejs.org |
| // (c) 2009-2015 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors |
| // Underscore may be freely distributed under the MIT license. |
| (function(){function n(n){function t(t,r,e,u,i,o){for(;i>=0&&o>i;i+=n){var a=u?u[i]:i;e=r(e,t[a],a,t)}return e}return function(r,e,u,i){e=b(e,i,4);var o=!k(r)&&m.keys(r),a=(o||r).length,c=n>0?0:a-1;return arguments.length<3&&(u=r[o?o[c]:c],c+=n),t(r,e,u,o,c,a)}}function t(n){return function(t,r,e){r=x(r,e);for(var u=O(t),i=n>0?0:u-1;i>=0&&u>i;i+=n)if(r(t[i],i,t))return i;return-1}}function r(n,t,r){return function(e,u,i){var o=0,a=O(e);if("number"==typeof i)n>0?o=i>=0?i:Math.max(i+a,o):a=i>=0?Math.min(i+1,a):i+a+1;else if(r&&i&&a)return i=r(e,u),e[i]===u?i:-1;if(u!==u)return i=t(l.call(e,o,a),m.isNaN),i>=0?i+o:-1;for(i=n>0?o:a-1;i>=0&&a>i;i+=n)if(e[i]===u)return i;return-1}}function e(n,t){var r=I.length,e=n.constructor,u=m.isFunction(e)&&e.prototype||a,i="constructor";for(m.has(n,i)&&!m.contains(t,i)&&t.push(i);r--;)i=I[r],i in n&&n[i]!==u[i]&&!m.contains(t,i)&&t.push(i)}var u=this,i=u._,o=Array.prototype,a=Object.prototype,c=Function.prototype,f=o.push,l=o.slice,s=a.toString,p=a.hasOwnProperty,h=Array.isArray,v=Object.keys,g=c.bind,y=Object.create,d=function(){},m=function(n){return n instanceof m?n:this instanceof m?void(this._wrapped=n):new m(n)};"undefined"!=typeof exports?("undefined"!=typeof module&&module.exports&&(exports=module.exports=m),exports._=m):u._=m,m.VERSION="1.8.3";var b=function(n,t,r){if(t===void 0)return n;switch(null==r?3:r){case 1:return function(r){return n.call(t,r)};case 2:return function(r,e){return n.call(t,r,e)};case 3:return function(r,e,u){return n.call(t,r,e,u)};case 4:return function(r,e,u,i){return n.call(t,r,e,u,i)}}return function(){return n.apply(t,arguments)}},x=function(n,t,r){return null==n?m.identity:m.isFunction(n)?b(n,t,r):m.isObject(n)?m.matcher(n):m.property(n)};m.iteratee=function(n,t){return x(n,t,1/0)};var _=function(n,t){return function(r){var e=arguments.length;if(2>e||null==r)return r;for(var u=1;e>u;u++)for(var i=arguments[u],o=n(i),a=o.length,c=0;a>c;c++){var f=o[c];t&&r[f]!==void 0||(r[f]=i[f])}return r}},j=function(n){if(!m.isObject(n))return{};if(y)return y(n);d.prototype=n;var t=new d;return d.prototype=null,t},w=function(n){return function(t){return null==t?void 0:t[n]}},A=Math.pow(2,53)-1,O=w("length"),k=function(n){var t=O(n);return"number"==typeof t&&t>=0&&A>=t};m.each=m.forEach=function(n,t,r){t=b(t,r);var e,u;if(k(n))for(e=0,u=n.length;u>e;e++)t(n[e],e,n);else{var i=m.keys(n);for(e=0,u=i.length;u>e;e++)t(n[i[e]],i[e],n)}return n},m.map=m.collect=function(n,t,r){t=x(t,r);for(var e=!k(n)&&m.keys(n),u=(e||n).length,i=Array(u),o=0;u>o;o++){var a=e?e[o]:o;i[o]=t(n[a],a,n)}return i},m.reduce=m.foldl=m.inject=n(1),m.reduceRight=m.foldr=n(-1),m.find=m.detect=function(n,t,r){var e;return e=k(n)?m.findIndex(n,t,r):m.findKey(n,t,r),e!==void 0&&e!==-1?n[e]:void 0},m.filter=m.select=function(n,t,r){var e=[];return t=x(t,r),m.each(n,function(n,r,u){t(n,r,u)&&e.push(n)}),e},m.reject=function(n,t,r){return m.filter(n,m.negate(x(t)),r)},m.every=m.all=function(n,t,r){t=x(t,r);for(var e=!k(n)&&m.keys(n),u=(e||n).length,i=0;u>i;i++){var o=e?e[i]:i;if(!t(n[o],o,n))return!1}return!0},m.some=m.any=function(n,t,r){t=x(t,r);for(var e=!k(n)&&m.keys(n),u=(e||n).length,i=0;u>i;i++){var o=e?e[i]:i;if(t(n[o],o,n))return!0}return!1},m.contains=m.includes=m.include=function(n,t,r,e){return k(n)||(n=m.values(n)),("number"!=typeof r||e)&&(r=0),m.indexOf(n,t,r)>=0},m.invoke=function(n,t){var r=l.call(arguments,2),e=m.isFunction(t);return m.map(n,function(n){var u=e?t:n[t];return null==u?u:u.apply(n,r)})},m.pluck=function(n,t){return m.map(n,m.property(t))},m.where=function(n,t){return m.filter(n,m.matcher(t))},m.findWhere=function(n,t){return m.find(n,m.matcher(t))},m.max=function(n,t,r){var e,u,i=-1/0,o=-1/0;if(null==t&&null!=n){n=k(n)?n:m.values(n);for(var a=0,c=n.length;c>a;a++)e=n[a],e>i&&(i=e)}else t=x(t,r),m.each(n,function(n,r,e){u=t(n,r,e),(u>o||u===-1/0&&i===-1/0)&&(i=n,o=u)});return i},m.min=function(n,t,r){var e,u,i=1/0,o=1/0;if(null==t&&null!=n){n=k(n)?n:m.values(n);for(var a=0,c=n.length;c>a;a++)e=n[a],i>e&&(i=e)}else t=x(t,r),m.each(n,function(n,r,e){u=t(n,r,e),(o>u||1/0===u&&1/0===i)&&(i=n,o=u)});return i},m.shuffle=function(n){for(var t,r=k(n)?n:m.values(n),e=r.length,u=Array(e),i=0;e>i;i++)t=m.random(0,i),t!==i&&(u[i]=u[t]),u[t]=r[i];return u},m.sample=function(n,t,r){return null==t||r?(k(n)||(n=m.values(n)),n[m.random(n.length-1)]):m.shuffle(n).slice(0,Math.max(0,t))},m.sortBy=function(n,t,r){return t=x(t,r),m.pluck(m.map(n,function(n,r,e){return{value:n,index:r,criteria:t(n,r,e)}}).sort(function(n,t){var r=n.criteria,e=t.criteria;if(r!==e){if(r>e||r===void 0)return 1;if(e>r||e===void 0)return-1}return n.index-t.index}),"value")};var F=function(n){return function(t,r,e){var u={};return r=x(r,e),m.each(t,function(e,i){var o=r(e,i,t);n(u,e,o)}),u}};m.groupBy=F(function(n,t,r){m.has(n,r)?n[r].push(t):n[r]=[t]}),m.indexBy=F(function(n,t,r){n[r]=t}),m.countBy=F(function(n,t,r){m.has(n,r)?n[r]++:n[r]=1}),m.toArray=function(n){return n?m.isArray(n)?l.call(n):k(n)?m.map(n,m.identity):m.values(n):[]},m.size=function(n){return null==n?0:k(n)?n.length:m.keys(n).length},m.partition=function(n,t,r){t=x(t,r);var e=[],u=[];return m.each(n,function(n,r,i){(t(n,r,i)?e:u).push(n)}),[e,u]},m.first=m.head=m.take=function(n,t,r){return null==n?void 0:null==t||r?n[0]:m.initial(n,n.length-t)},m.initial=function(n,t,r){return l.call(n,0,Math.max(0,n.length-(null==t||r?1:t)))},m.last=function(n,t,r){return null==n?void 0:null==t||r?n[n.length-1]:m.rest(n,Math.max(0,n.length-t))},m.rest=m.tail=m.drop=function(n,t,r){return l.call(n,null==t||r?1:t)},m.compact=function(n){return m.filter(n,m.identity)};var S=function(n,t,r,e){for(var u=[],i=0,o=e||0,a=O(n);a>o;o++){var c=n[o];if(k(c)&&(m.isArray(c)||m.isArguments(c))){t||(c=S(c,t,r));var f=0,l=c.length;for(u.length+=l;l>f;)u[i++]=c[f++]}else r||(u[i++]=c)}return u};m.flatten=function(n,t){return S(n,t,!1)},m.without=function(n){return m.difference(n,l.call(arguments,1))},m.uniq=m.unique=function(n,t,r,e){m.isBoolean(t)||(e=r,r=t,t=!1),null!=r&&(r=x(r,e));for(var u=[],i=[],o=0,a=O(n);a>o;o++){var c=n[o],f=r?r(c,o,n):c;t?(o&&i===f||u.push(c),i=f):r?m.contains(i,f)||(i.push(f),u.push(c)):m.contains(u,c)||u.push(c)}return u},m.union=function(){return m.uniq(S(arguments,!0,!0))},m.intersection=function(n){for(var t=[],r=arguments.length,e=0,u=O(n);u>e;e++){var i=n[e];if(!m.contains(t,i)){for(var o=1;r>o&&m.contains(arguments[o],i);o++);o===r&&t.push(i)}}return t},m.difference=function(n){var t=S(arguments,!0,!0,1);return m.filter(n,function(n){return!m.contains(t,n)})},m.zip=function(){return m.unzip(arguments)},m.unzip=function(n){for(var t=n&&m.max(n,O).length||0,r=Array(t),e=0;t>e;e++)r[e]=m.pluck(n,e);return r},m.object=function(n,t){for(var r={},e=0,u=O(n);u>e;e++)t?r[n[e]]=t[e]:r[n[e][0]]=n[e][1];return r},m.findIndex=t(1),m.findLastIndex=t(-1),m.sortedIndex=function(n,t,r,e){r=x(r,e,1);for(var u=r(t),i=0,o=O(n);o>i;){var a=Math.floor((i+o)/2);r(n[a])<u?i=a+1:o=a}return i},m.indexOf=r(1,m.findIndex,m.sortedIndex),m.lastIndexOf=r(-1,m.findLastIndex),m.range=function(n,t,r){null==t&&(t=n||0,n=0),r=r||1;for(var e=Math.max(Math.ceil((t-n)/r),0),u=Array(e),i=0;e>i;i++,n+=r)u[i]=n;return u};var E=function(n,t,r,e,u){if(!(e instanceof t))return n.apply(r,u);var i=j(n.prototype),o=n.apply(i,u);return m.isObject(o)?o:i};m.bind=function(n,t){if(g&&n.bind===g)return g.apply(n,l.call(arguments,1));if(!m.isFunction(n))throw new TypeError("Bind must be called on a function");var r=l.call(arguments,2),e=function(){return E(n,e,t,this,r.concat(l.call(arguments)))};return e},m.partial=function(n){var t=l.call(arguments,1),r=function(){for(var e=0,u=t.length,i=Array(u),o=0;u>o;o++)i[o]=t[o]===m?arguments[e++]:t[o];for(;e<arguments.length;)i.push(arguments[e++]);return E(n,r,this,this,i)};return r},m.bindAll=function(n){var t,r,e=arguments.length;if(1>=e)throw new Error("bindAll must be passed function names");for(t=1;e>t;t++)r=arguments[t],n[r]=m.bind(n[r],n);return n},m.memoize=function(n,t){var r=function(e){var u=r.cache,i=""+(t?t.apply(this,arguments):e);return m.has(u,i)||(u[i]=n.apply(this,arguments)),u[i]};return r.cache={},r},m.delay=function(n,t){var r=l.call(arguments,2);return setTimeout(function(){return n.apply(null,r)},t)},m.defer=m.partial(m.delay,m,1),m.throttle=function(n,t,r){var e,u,i,o=null,a=0;r||(r={});var c=function(){a=r.leading===!1?0:m.now(),o=null,i=n.apply(e,u),o||(e=u=null)};return function(){var f=m.now();a||r.leading!==!1||(a=f);var l=t-(f-a);return e=this,u=arguments,0>=l||l>t?(o&&(clearTimeout(o),o=null),a=f,i=n.apply(e,u),o||(e=u=null)):o||r.trailing===!1||(o=setTimeout(c,l)),i}},m.debounce=function(n,t,r){var e,u,i,o,a,c=function(){var f=m.now()-o;t>f&&f>=0?e=setTimeout(c,t-f):(e=null,r||(a=n.apply(i,u),e||(i=u=null)))};return function(){i=this,u=arguments,o=m.now();var f=r&&!e;return e||(e=setTimeout(c,t)),f&&(a=n.apply(i,u),i=u=null),a}},m.wrap=function(n,t){return m.partial(t,n)},m.negate=function(n){return function(){return!n.apply(this,arguments)}},m.compose=function(){var n=arguments,t=n.length-1;return function(){for(var r=t,e=n[t].apply(this,arguments);r--;)e=n[r].call(this,e);return e}},m.after=function(n,t){return function(){return--n<1?t.apply(this,arguments):void 0}},m.before=function(n,t){var r;return function(){return--n>0&&(r=t.apply(this,arguments)),1>=n&&(t=null),r}},m.once=m.partial(m.before,2);var M=!{toString:null}.propertyIsEnumerable("toString"),I=["valueOf","isPrototypeOf","toString","propertyIsEnumerable","hasOwnProperty","toLocaleString"];m.keys=function(n){if(!m.isObject(n))return[];if(v)return v(n);var t=[];for(var r in n)m.has(n,r)&&t.push(r);return M&&e(n,t),t},m.allKeys=function(n){if(!m.isObject(n))return[];var t=[];for(var r in n)t.push(r);return M&&e(n,t),t},m.values=function(n){for(var t=m.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=n[t[u]];return e},m.mapObject=function(n,t,r){t=x(t,r);for(var e,u=m.keys(n),i=u.length,o={},a=0;i>a;a++)e=u[a],o[e]=t(n[e],e,n);return o},m.pairs=function(n){for(var t=m.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=[t[u],n[t[u]]];return e},m.invert=function(n){for(var t={},r=m.keys(n),e=0,u=r.length;u>e;e++)t[n[r[e]]]=r[e];return t},m.functions=m.methods=function(n){var t=[];for(var r in n)m.isFunction(n[r])&&t.push(r);return t.sort()},m.extend=_(m.allKeys),m.extendOwn=m.assign=_(m.keys),m.findKey=function(n,t,r){t=x(t,r);for(var e,u=m.keys(n),i=0,o=u.length;o>i;i++)if(e=u[i],t(n[e],e,n))return e},m.pick=function(n,t,r){var e,u,i={},o=n;if(null==o)return i;m.isFunction(t)?(u=m.allKeys(o),e=b(t,r)):(u=S(arguments,!1,!1,1),e=function(n,t,r){return t in r},o=Object(o));for(var a=0,c=u.length;c>a;a++){var f=u[a],l=o[f];e(l,f,o)&&(i[f]=l)}return i},m.omit=function(n,t,r){if(m.isFunction(t))t=m.negate(t);else{var e=m.map(S(arguments,!1,!1,1),String);t=function(n,t){return!m.contains(e,t)}}return m.pick(n,t,r)},m.defaults=_(m.allKeys,!0),m.create=function(n,t){var r=j(n);return t&&m.extendOwn(r,t),r},m.clone=function(n){return m.isObject(n)?m.isArray(n)?n.slice():m.extend({},n):n},m.tap=function(n,t){return t(n),n},m.isMatch=function(n,t){var r=m.keys(t),e=r.length;if(null==n)return!e;for(var u=Object(n),i=0;e>i;i++){var o=r[i];if(t[o]!==u[o]||!(o in u))return!1}return!0};var N=function(n,t,r,e){if(n===t)return 0!==n||1/n===1/t;if(null==n||null==t)return n===t;n instanceof m&&(n=n._wrapped),t instanceof m&&(t=t._wrapped);var u=s.call(n);if(u!==s.call(t))return!1;switch(u){case"[object RegExp]":case"[object String]":return""+n==""+t;case"[object Number]":return+n!==+n?+t!==+t:0===+n?1/+n===1/t:+n===+t;case"[object Date]":case"[object Boolean]":return+n===+t}var i="[object Array]"===u;if(!i){if("object"!=typeof n||"object"!=typeof t)return!1;var o=n.constructor,a=t.constructor;if(o!==a&&!(m.isFunction(o)&&o instanceof o&&m.isFunction(a)&&a instanceof a)&&"constructor"in n&&"constructor"in t)return!1}r=r||[],e=e||[];for(var c=r.length;c--;)if(r[c]===n)return e[c]===t;if(r.push(n),e.push(t),i){if(c=n.length,c!==t.length)return!1;for(;c--;)if(!N(n[c],t[c],r,e))return!1}else{var f,l=m.keys(n);if(c=l.length,m.keys(t).length!==c)return!1;for(;c--;)if(f=l[c],!m.has(t,f)||!N(n[f],t[f],r,e))return!1}return r.pop(),e.pop(),!0};m.isEqual=function(n,t){return N(n,t)},m.isEmpty=function(n){return null==n?!0:k(n)&&(m.isArray(n)||m.isString(n)||m.isArguments(n))?0===n.length:0===m.keys(n).length},m.isElement=function(n){return!(!n||1!==n.nodeType)},m.isArray=h||function(n){return"[object Array]"===s.call(n)},m.isObject=function(n){var t=typeof n;return"function"===t||"object"===t&&!!n},m.each(["Arguments","Function","String","Number","Date","RegExp","Error"],function(n){m["is"+n]=function(t){return s.call(t)==="[object "+n+"]"}}),m.isArguments(arguments)||(m.isArguments=function(n){return m.has(n,"callee")}),"function"!=typeof/./&&"object"!=typeof Int8Array&&(m.isFunction=function(n){return"function"==typeof n||!1}),m.isFinite=function(n){return isFinite(n)&&!isNaN(parseFloat(n))},m.isNaN=function(n){return m.isNumber(n)&&n!==+n},m.isBoolean=function(n){return n===!0||n===!1||"[object Boolean]"===s.call(n)},m.isNull=function(n){return null===n},m.isUndefined=function(n){return n===void 0},m.has=function(n,t){return null!=n&&p.call(n,t)},m.noConflict=function(){return u._=i,this},m.identity=function(n){return n},m.constant=function(n){return function(){return n}},m.noop=function(){},m.property=w,m.propertyOf=function(n){return null==n?function(){}:function(t){return n[t]}},m.matcher=m.matches=function(n){return n=m.extendOwn({},n),function(t){return m.isMatch(t,n)}},m.times=function(n,t,r){var e=Array(Math.max(0,n));t=b(t,r,1);for(var u=0;n>u;u++)e[u]=t(u);return e},m.random=function(n,t){return null==t&&(t=n,n=0),n+Math.floor(Math.random()*(t-n+1))},m.now=Date.now||function(){return(new Date).getTime()};var B={"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"},T=m.invert(B),R=function(n){var t=function(t){return n[t]},r="(?:"+m.keys(n).join("|")+")",e=RegExp(r),u=RegExp(r,"g");return function(n){return n=null==n?"":""+n,e.test(n)?n.replace(u,t):n}};m.escape=R(B),m.unescape=R(T),m.result=function(n,t,r){var e=null==n?void 0:n[t];return e===void 0&&(e=r),m.isFunction(e)?e.call(n):e};var q=0;m.uniqueId=function(n){var t=++q+"";return n?n+t:t},m.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var K=/(.)^/,z={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},D=/\\|'|\r|\n|\u2028|\u2029/g,L=function(n){return"\\"+z[n]};m.template=function(n,t,r){!t&&r&&(t=r),t=m.defaults({},t,m.templateSettings);var e=RegExp([(t.escape||K).source,(t.interpolate||K).source,(t.evaluate||K).source].join("|")+"|$","g"),u=0,i="__p+='";n.replace(e,function(t,r,e,o,a){return i+=n.slice(u,a).replace(D,L),u=a+t.length,r?i+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'":e?i+="'+\n((__t=("+e+"))==null?'':__t)+\n'":o&&(i+="';\n"+o+"\n__p+='"),t}),i+="';\n",t.variable||(i="with(obj||{}){\n"+i+"}\n"),i="var __t,__p='',__j=Array.prototype.join,"+"print=function(){__p+=__j.call(arguments,'');};\n"+i+"return __p;\n";try{var o=new Function(t.variable||"obj","_",i)}catch(a){throw a.source=i,a}var c=function(n){return o.call(this,n,m)},f=t.variable||"obj";return c.source="function("+f+"){\n"+i+"}",c},m.chain=function(n){var t=m(n);return t._chain=!0,t};var P=function(n,t){return n._chain?m(t).chain():t};m.mixin=function(n){m.each(m.functions(n),function(t){var r=m[t]=n[t];m.prototype[t]=function(){var n=[this._wrapped];return f.apply(n,arguments),P(this,r.apply(m,n))}})},m.mixin(m),m.each(["pop","push","reverse","shift","sort","splice","unshift"],function(n){var t=o[n];m.prototype[n]=function(){var r=this._wrapped;return t.apply(r,arguments),"shift"!==n&&"splice"!==n||0!==r.length||delete r[0],P(this,r)}}),m.each(["concat","join","slice"],function(n){var t=o[n];m.prototype[n]=function(){return P(this,t.apply(this._wrapped,arguments))}}),m.prototype.value=function(){return this._wrapped},m.prototype.valueOf=m.prototype.toJSON=m.prototype.value,m.prototype.toString=function(){return""+this._wrapped},"function"==typeof define&&define.amd&&define("underscore",[],function(){return m})}).call(this); |
| |
| |
| 'use strict'; |
| |
| var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })(); |
| |
| function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } } |
| |
| function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } |
| |
| var ToolTip = (function (_React$Component) { |
| _inherits(ToolTip, _React$Component); |
| |
| function ToolTip(props) { |
| _classCallCheck(this, ToolTip); |
| |
| _React$Component.call(this, props); |
| } |
| |
| ToolTip.prototype.componentDidMount = function componentDidMount() { |
| var _this = this; |
| $(".react-tooltip").tooltipster({ |
| animation: _this.props.animation, |
| speed: _this.props.speed, |
| delay: _this.props.delay, |
| theme: _this.props.theme, |
| contentAsHTML: _this.props.contentAsHTML, |
| trigger: _this.props.trigger, |
| position: _this.props.position, |
| multiple: _this.props.multiple, |
| iconCloning: false, |
| maxWidth: _this.props.maxWidth |
| }); |
| }; |
| |
| _createClass(ToolTip, null, [{ |
| key: 'propTypes', |
| value: { |
| animation: React.PropTypes.string, |
| speed: React.PropTypes.number, |
| position: React.PropTypes.string, |
| contentAsHTML: React.PropTypes.bool, |
| delay: React.PropTypes.number, |
| theme: React.PropTypes.string, |
| maxWidth: React.PropTypes.number, |
| trigger: React.PropTypes.string, |
| multiple: React.PropTypes.bool, |
| classes: React.PropTypes.array, |
| text: React.PropTypes.string.isRequired, |
| href: React.PropTypes.string.isRequired, |
| toolTip: React.PropTypes.string |
| }, |
| enumerable: true |
| }, { |
| key: 'defaultProps', |
| value: { |
| animation: 'fade', |
| speed: 150, |
| delay: 0, |
| maxWidth: 300, |
| multiple: true, |
| contentAsHTML: false, |
| position: 'left', |
| trigger: 'hover', |
| classes: [], |
| theme: 'tooltipster-light' |
| }, |
| enumerable: true |
| }]); |
| |
| return ToolTip; |
| })(React.Component); |
| |
| var ToolTipLink = (function (_ToolTip) { |
| _inherits(ToolTipLink, _ToolTip); |
| |
| function ToolTipLink(props) { |
| _classCallCheck(this, ToolTipLink); |
| |
| _ToolTip.call(this, props); |
| } |
| |
| ToolTipLink.prototype.render = function render() { |
| var classes = this.props.classes.join(' ') + " react-tooltip"; |
| return React.createElement( |
| 'a', |
| { href: this.props.href, className: classes, title: this.props.toolTip }, |
| this.props.text |
| ); |
| }; |
| |
| return ToolTipLink; |
| })(ToolTip); |
| |
| |
| 'use strict'; |
| |
| var _extends = Object.assign || function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; |
| |
| function _getProjectUrl() { |
| var rest = arguments.length <= 0 || arguments[0] === undefined ? true : arguments[0]; |
| |
| var nbhd, proj, nbhd_proj; |
| var ident_classes = document.getElementById('page-body').className.split(' '); |
| var _iteratorNormalCompletion = true; |
| var _didIteratorError = false; |
| var _iteratorError = undefined; |
| |
| try { |
| for (var _iterator = ident_classes[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) { |
| var cls = _step.value; |
| |
| if (cls.indexOf('project-') === 0) { |
| proj = cls.slice('project-'.length); |
| } |
| } |
| } catch (err) { |
| _didIteratorError = true; |
| _iteratorError = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion && _iterator['return']) { |
| _iterator['return'](); |
| } |
| } finally { |
| if (_didIteratorError) { |
| throw _iteratorError; |
| } |
| } |
| } |
| |
| nbhd = window.location.pathname.split('/')[1]; |
| if (proj === '--init--') { |
| nbhd_proj = nbhd; |
| } else { |
| nbhd_proj = nbhd + '/' + proj; |
| } |
| return (rest ? '/rest/' : '/') + nbhd_proj; |
| } |
| |
| function getMountPoint(node) { |
| if (node.hasOwnProperty('mount_point') && node['mount_point'] !== null) { |
| return node['mount_point']; |
| } |
| return node.props.children[0].props.mount_point; |
| } |
| |
| function getUrlByNode(node) { |
| if (node.hasOwnProperty('url') && node['url'] !== null) { |
| return node['url']; |
| } |
| return node.props.children[0].props.url; |
| } |
| |
| var ToolsPropType = React.PropTypes.shape({ |
| mount_point: React.PropTypes.string, |
| name: React.PropTypes.string.isRequired, |
| url: React.PropTypes.string.isRequired, |
| is_anchored: React.PropTypes.bool.isRequired, |
| tool_name: React.PropTypes.string.isRequired, |
| icon: React.PropTypes.string, |
| children: React.PropTypes.array, |
| admin_options: React.PropTypes.array |
| }); |
| |
| var NavBarItem = React.createClass({ |
| displayName: 'NavBarItem', |
| |
| propTypes: { |
| name: React.PropTypes.string.isRequired, |
| url: React.PropTypes.string.isRequired, |
| currentOptionMenu: React.PropTypes.object, |
| onOptionClick: React.PropTypes.func.isRequired, |
| options: React.PropTypes.array |
| }, |
| |
| isAnchored: function isAnchored() { |
| return this.props.is_anchored !== null; |
| }, |
| |
| render: function render() { |
| var divClasses = "tb-item tb-item-edit"; |
| if (this.props.is_anchored) { |
| divClasses += " anchored"; |
| } |
| var spanClasses = this.props.handleType + " ordinal-item"; |
| if (this.props.isGrouper) { |
| spanClasses += " toolbar-grouper"; |
| } |
| |
| return React.createElement( |
| 'div', |
| { className: divClasses }, |
| React.createElement( |
| 'a', |
| null, |
| !_.isEmpty(this.props.options) && React.createElement('i', { className: 'config-tool fa fa-cog', onClick: this.handleOptionClick }), |
| React.createElement( |
| 'span', |
| { |
| className: spanClasses, |
| 'data-mount-point': this.props.mount_point }, |
| this.props.name |
| ) |
| ), |
| this.props.currentOptionMenu.tool && this.props.currentOptionMenu.tool === this.props.mount_point && React.createElement(ContextMenu, _extends({}, this.props, { |
| classes: ['tool-options'], |
| items: this.props.options, |
| onOptionClick: this.props.onOptionClick |
| })) |
| ); |
| }, |
| |
| handleOptionClick: function handleOptionClick(event) { |
| this.props.onOptionClick(this.props.mount_point); |
| } |
| }); |
| |
| var GroupingThreshold = React.createClass({ |
| displayName: 'GroupingThreshold', |
| |
| propTypes: { |
| initialValue: React.PropTypes.number.isRequired |
| }, |
| getInitialState: function getInitialState() { |
| return { |
| value: this.props.initialValue |
| }; |
| }, |
| |
| handleChange: function handleChange(event) { |
| this.setState({ |
| value: event.target.value |
| }); |
| this.props.onUpdateThreshold(event); |
| }, |
| |
| render: function render() { |
| return React.createElement( |
| 'div', |
| null, |
| !!this.props.isHidden && React.createElement( |
| 'div', |
| { id: 'threshold-config' }, |
| React.createElement( |
| 'span', |
| null, |
| React.createElement( |
| 'label', |
| { htmlFor: 'threshold-input' }, |
| 'Grouping Threshold' |
| ), |
| React.createElement('input', { type: 'number', name: 'threshold-input', className: 'tooltip', |
| title: 'Number of tools allowed before grouping.', |
| value: this.state.value, |
| onChange: this.handleChange, |
| min: '1', max: '10' }) |
| ) |
| ) |
| ); |
| } |
| }); |
| |
| var NormalNavItem = React.createClass({ |
| displayName: 'NormalNavItem', |
| |
| mixins: [React.addons.PureRenderMixin], |
| |
| render: function render() { |
| |
| return React.createElement( |
| 'li', |
| { key: 'tb-norm-' + _.uniqueId() }, |
| React.createElement( |
| 'a', |
| { href: this.props.url, className: this.props.classes }, |
| this.props.name |
| ), |
| this.props.children |
| ); |
| } |
| }); |
| |
| var ToggleAddNewTool = React.createClass({ |
| displayName: 'ToggleAddNewTool', |
| |
| getInitialState: function getInitialState() { |
| return { |
| visible: false |
| }; |
| }, |
| handleToggle: function handleToggle() { |
| this.setState({ |
| visible: !this.state.visible |
| }); |
| }, |
| handleOptionClick: function handleOptionClick(event) { |
| console.log('event', event); |
| }, |
| |
| render: function render() { |
| return React.createElement( |
| 'div', |
| null, |
| React.createElement( |
| 'a', |
| { onClick: this.handleToggle, className: 'add-tool-toggle' }, |
| 'Add New...' |
| ), |
| this.state.visible && React.createElement(ContextMenu, _extends({}, this.props, { |
| classes: ['admin_modal'], |
| onOptionClick: this.handleOptionClick, |
| items: this.props.installableTools })) |
| ); |
| } |
| }); |
| |
| var NormalNavBar = React.createClass({ |
| displayName: 'NormalNavBar', |
| |
| buildMenu: function buildMenu(item, i) { |
| var classes = window.location.pathname.startsWith(item.url) ? 'active-nav-link' : ''; |
| |
| var subMenu; |
| if (item.children) { |
| subMenu = item.children.map(this.buildMenu); |
| } |
| return React.createElement( |
| NormalNavItem, |
| { url: item.url, name: item.name, classes: classes, key: 'normal-nav-' + _.uniqueId() }, |
| React.createElement( |
| 'ul', |
| null, |
| subMenu |
| ) |
| ); |
| }, |
| |
| onOptionClick: function onOptionClick(e) { |
| console.log(e); |
| }, |
| render: function render() { |
| var listItems = this.props.items.map(this.buildMenu); |
| |
| var mount_points = []; |
| var _iteratorNormalCompletion2 = true; |
| var _didIteratorError2 = false; |
| var _iteratorError2 = undefined; |
| |
| try { |
| for (var _iterator2 = this.props.items[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) { |
| var item = _step2.value; |
| |
| if (item.hasOwnProperty('mount_point') && item.mount_point !== null) { |
| mount_points.push(item.mount_point); |
| } else if (item.hasOwnProperty('children')) { |
| var _iteratorNormalCompletion3 = true; |
| var _didIteratorError3 = false; |
| var _iteratorError3 = undefined; |
| |
| try { |
| for (var _iterator3 = item.children[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) { |
| var child = _step3.value; |
| |
| mount_points.push(child.mount_point); |
| } |
| } catch (err) { |
| _didIteratorError3 = true; |
| _iteratorError3 = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion3 && _iterator3['return']) { |
| _iterator3['return'](); |
| } |
| } finally { |
| if (_didIteratorError3) { |
| throw _iteratorError3; |
| } |
| } |
| } |
| } |
| } |
| } catch (err) { |
| _didIteratorError2 = true; |
| _iteratorError2 = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion2 && _iterator2['return']) { |
| _iterator2['return'](); |
| } |
| } finally { |
| if (_didIteratorError2) { |
| throw _iteratorError2; |
| } |
| } |
| } |
| |
| console.log("mount_points", mount_points); |
| return React.createElement( |
| 'ul', |
| { |
| id: 'normal-nav-bar', |
| className: 'dropdown' }, |
| listItems, |
| React.createElement( |
| 'li', |
| { id: 'add-tool-container' }, |
| React.createElement(ToggleAddNewTool, _extends({}, this.props, { |
| items: this.props.installableTools, |
| onOptionClick: this.onOptionClick })) |
| ) |
| ); |
| } |
| }); |
| |
| var AdminNav = React.createClass({ |
| displayName: 'AdminNav', |
| |
| propTypes: { |
| tools: React.PropTypes.arrayOf(ToolsPropType), |
| currentOptionMenu: React.PropTypes.object, |
| onOptionClick: React.PropTypes.func.isRequired |
| }, |
| |
| buildMenu: function buildMenu(items) { |
| var isSubMenu = arguments.length <= 1 || arguments[1] === undefined ? false : arguments[1]; |
| |
| var _this = this; |
| var tools = []; |
| var anchored_tools = []; |
| var end_tools = []; |
| |
| var subMenu, childOptionsOpen; |
| |
| var _iteratorNormalCompletion4 = true; |
| var _didIteratorError4 = false; |
| var _iteratorError4 = undefined; |
| |
| try { |
| for (var _iterator4 = items[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) { |
| var item = _step4.value; |
| |
| if (item.children) { |
| subMenu = this.buildMenu(item.children, true); |
| } else { |
| subMenu = null; |
| } |
| |
| var _handle = isSubMenu ? "draggable-handle-sub" : 'draggable-handle'; |
| |
| var tool_list, is_anchored; |
| if (item.mount_point === 'admin') { |
| tool_list = end_tools; |
| is_anchored = true; |
| } else if (item.is_anchored) { |
| tool_list = anchored_tools; |
| is_anchored = true; |
| } else { |
| tool_list = tools; |
| is_anchored = false; |
| } |
| var core_item = React.createElement(NavBarItem, _extends({}, _this.props, { |
| mount_point: item.mount_point, |
| name: item.name, |
| handleType: _handle, |
| isGrouper: item.children && item.children.length > 0, |
| url: item.url, |
| key: 'tb-item-' + _.uniqueId(), |
| is_anchored: is_anchored, |
| options: item.admin_options |
| })); |
| if (subMenu) { |
| childOptionsOpen = _.contains(_.pluck(item.children, 'mount_point'), this.props.currentOptionMenu.tool); |
| tool_list.push(React.createElement(NavBarItemWithSubMenu, { key: _.uniqueId(), tool: core_item, subMenu: subMenu, childOptionsOpen: childOptionsOpen })); |
| } else { |
| tool_list.push(core_item); |
| } |
| } |
| } catch (err) { |
| _didIteratorError4 = true; |
| _iteratorError4 = err; |
| } finally { |
| try { |
| if (!_iteratorNormalCompletion4 && _iterator4['return']) { |
| _iterator4['return'](); |
| } |
| } finally { |
| if (_didIteratorError4) { |
| throw _iteratorError4; |
| } |
| } |
| } |
| |
| return React.createElement( |
| 'div', |
| { className: 'react-drag' }, |
| anchored_tools, |
| React.createElement( |
| ReactReorderable, |
| { |
| key: 'reorder-' + _.uniqueId(), |
| handle: "." + _handle, |
| mode: isSubMenu ? 'list' : 'grid', |
| onDragStart: _this.props.onToolDragStart, |
| onDrop: _this.props.onToolReorder }, |
| tools |
| ), |
| end_tools |
| ); |
| }, |
| |
| render: function render() { |
| var tools = this.buildMenu(this.props.tools); |
| return React.createElement( |
| 'div', |
| null, |
| tools |
| ); |
| } |
| }); |
| |
| var NavBarItemWithSubMenu = React.createClass({ |
| displayName: 'NavBarItemWithSubMenu', |
| |
| render: function render() { |
| return React.createElement( |
| 'div', |
| { className: "tb-item-container" + (this.props.childOptionsOpen ? " child-options-open" : "") }, |
| this.props.tool, |
| this.props.subMenu && React.createElement( |
| AdminItemGroup, |
| { key: _.uniqueId() }, |
| this.props.subMenu |
| ) |
| ); |
| } |
| }); |
| |
| var AdminItemGroup = React.createClass({ |
| displayName: 'AdminItemGroup', |
| |
| render: function render() { |
| return React.createElement( |
| 'div', |
| { className: 'tb-item-grouper' }, |
| this.props.children |
| ); |
| } |
| }); |
| |
| var ToggleAdminButton = React.createClass({ |
| displayName: 'ToggleAdminButton', |
| |
| propTypes: { |
| visible: React.PropTypes.bool |
| }, |
| render: function render() { |
| var classes = this.props.visible ? 'fa fa-unlock' : 'fa fa-lock'; |
| return React.createElement( |
| 'button', |
| { id: 'toggle-admin-btn', onClick: this.props.handleButtonPush, className: 'admin-toolbar-right' }, |
| React.createElement('i', { className: classes }) |
| ); |
| } |
| }); |
| |
| var Main = React.createClass({ |
| displayName: 'Main', |
| |
| propTypes: { |
| initialData: React.PropTypes.shape({ |
| menu: React.PropTypes.arrayOf(ToolsPropType), |
| installableTools: React.PropTypes.array, |
| grouping_threshold: React.PropTypes.number.isRequired |
| }), |
| installableTools: React.PropTypes.array |
| }, |
| getInitialState: function getInitialState() { |
| return { |
| data: this.props.initialData, |
| visible: true, |
| _session_id: $.cookie('_session_id'), |
| currentOptionMenu: { |
| tool: null |
| } |
| }; |
| }, |
| |
| getNavJson: function getNavJson() { |
| $.get(_getProjectUrl(false) + '/_nav.json?admin_options=1', (function (result) { |
| if (this.isMounted()) { |
| this.setState({ |
| data: result |
| }); |
| } |
| }).bind(this)); |
| }, |
| |
| handleToggleAdmin: function handleToggleAdmin() { |
| this.setState({ |
| visible: !this.state.visible |
| }); |
| }, |
| |
| handleShowOptionMenu: function handleShowOptionMenu(mount_point) { |
| this.setState({ |
| currentOptionMenu: { |
| tool: mount_point |
| } |
| }); |
| }, |
| |
| onUpdateThreshold: function onUpdateThreshold(event) { |
| var _this = this; |
| var thres = event.target.value; |
| var url = _getProjectUrl() + '/admin/configure_tool_grouping'; |
| var csrf = $.cookie('_session_id'); |
| var data = { |
| _session_id: csrf, |
| grouping_threshold: thres |
| }; |
| var _data = this.state.data; |
| _data.grouping_threshold = thres; |
| this.setState({ |
| data: _data |
| }); |
| this.setState({ |
| in_progress: true |
| }); |
| $.post(url, data, (function () {}).bind(this)).always(function () { |
| _this.setState({ |
| in_progress: false |
| }); |
| }); |
| |
| _this.getNavJson(); |
| return false; |
| }, |
| |
| onToolReorder: function onToolReorder() { |
| $('.react-drag.dragging').removeClass('dragging'); |
| |
| var params = { _session_id: $.cookie('_session_id') }; |
| var toolNodes = $(ReactDOM.findDOMNode(this)).find('span.ordinal-item').not(".toolbar-grouper"); |
| for (var i = 0; i < toolNodes.length; i++) { |
| params[i] = toolNodes[i].dataset.mountPoint; |
| } |
| |
| var _this = this; |
| var url = _getProjectUrl() + '/admin/mount_order'; |
| $.ajax({ |
| type: 'POST', |
| url: url, |
| data: params, |
| success: function success() { |
| $('#messages').notify('Tool order updated', { |
| status: 'confirm', |
| interval: 500, |
| timer: 2000 |
| }); |
| _this.getNavJson(); |
| }, |
| |
| error: function error() { |
| $('#messages').notify('Error saving tool order.', { |
| status: 'error' |
| }); |
| } |
| }); |
| }, |
| |
| onToolDragStart: function onToolDragStart(obj) { |
| var dragging_mount_point = obj.props.children.props.mount_point; |
| $('[data-mount-point=' + dragging_mount_point + ']').closest('.react-drag').addClass('dragging'); |
| }, |
| |
| render: function render() { |
| var _this2 = this; |
| |
| var _this = this; |
| var navBarSwitch = function navBarSwitch(showAdmin) { |
| if (showAdmin) { |
| return React.createElement(AdminNav, { |
| tools: _this.state.data.menu, |
| installableTools: _this.state.data.installable_tools, |
| data: _this.state.data, |
| onToolReorder: _this.onToolReorder, |
| onToolDragStart: _this.onToolDragStart, |
| editMode: _this.state.visible, |
| currentOptionMenu: _this.state.currentOptionMenu, |
| onOptionClick: _this.handleShowOptionMenu, |
| currentToolOptions: _this2.state.currentToolOptions |
| }); |
| } else { |
| return React.createElement( |
| 'div', |
| null, |
| React.createElement(NormalNavBar, { |
| items: _this.state.data.menu, |
| installableTools: _this.state.data.installable_tools |
| }) |
| ); |
| } |
| }; |
| var navBar = navBarSwitch(this.state.visible); |
| |
| var max_tool_count = _.chain(this.state.data.menu).map(function (item) { |
| return item.children ? _.pluck(item.children, 'tool_name') : item.tool_name; |
| }).flatten().countBy().values().max().value(); |
| var show_grouping_threshold = max_tool_count > 1; |
| |
| return React.createElement( |
| 'div', |
| { |
| className: 'nav_admin ' }, |
| navBar, |
| React.createElement( |
| 'div', |
| { id: 'bar-config' }, |
| show_grouping_threshold && React.createElement(GroupingThreshold, { |
| onUpdateThreshold: this.onUpdateThreshold, |
| isHidden: this.state.visible, |
| initialValue: parseInt(this.state.data.grouping_threshold) }) |
| ), |
| React.createElement(ToggleAdminButton, { |
| handleButtonPush: this.handleToggleAdmin, |
| visible: this.state.visible }) |
| ); |
| } |
| }); |
| //# sourceMappingURL=navbar.map |