react 15.2.0 → 15.3.0-rc.3

package/lib/ReactTestMount.js

@@ -11,6 +11,8 @@
  */
 'use strict';
 
+var _prodInvariant = require('./reactProdInvariant');
+
 var ReactElement = require('./ReactElement');
 var ReactInstrumentation = require('./ReactInstrumentation');
 var ReactReconciler = require('./ReactReconciler');
@@ -19,6 +21,7 @@ var ReactUpdates = require('./ReactUpdates');
 var emptyObject = require('fbjs/lib/emptyObject');
 var getHostComponentFromComposite = require('./getHostComponentFromComposite');
 var instantiateReactComponent = require('./instantiateReactComponent');
+var invariant = require('fbjs/lib/invariant');
 
 /**
  * Temporary (?) hack so that we can store all top-level pending updates on
@@ -69,6 +72,29 @@ var ReactTestInstance = function (component) {
 ReactTestInstance.prototype.getInstance = function () {
   return this._component._renderedComponent.getPublicInstance();
 };
+ReactTestInstance.prototype.update = function (nextElement) {
+  !this._component ? process.env.NODE_ENV !== 'production' ? invariant(false, 'ReactTestRenderer: .update() can\'t be called after unmount.') : _prodInvariant('139') : void 0;
+  var nextWrappedElement = new ReactElement(TopLevelWrapper, null, null, null, null, null, nextElement);
+  var component = this._component;
+  ReactUpdates.batchedUpdates(function () {
+    var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(true);
+    transaction.perform(function () {
+      ReactReconciler.receiveComponent(component, nextWrappedElement, transaction, emptyObject);
+    });
+    ReactUpdates.ReactReconcileTransaction.release(transaction);
+  });
+};
+ReactTestInstance.prototype.unmount = function (nextElement) {
+  var component = this._component;
+  ReactUpdates.batchedUpdates(function () {
+    var transaction = ReactUpdates.ReactReconcileTransaction.getPooled(true);
+    transaction.perform(function () {
+      ReactReconciler.unmountComponent(component, false);
+    });
+    ReactUpdates.ReactReconcileTransaction.release(transaction);
+  });
+  this._component = null;
+};
 ReactTestInstance.prototype.toJSON = function () {
   var inst = getHostComponentFromComposite(this._component);
   return inst.toJSON();
@@ -78,35 +104,12 @@ ReactTestInstance.prototype.toJSON = function () {
  * As soon as `ReactMount` is refactored to not rely on the DOM, we can share
  * code between the two. For now, we'll hard code the ID logic.
  */
-var ReactHostMount = {
+var ReactTestMount = {
 
   render: function (nextElement) {
     var nextWrappedElement = new ReactElement(TopLevelWrapper, null, null, null, null, null, nextElement);
 
-    // var prevComponent = ReactHostMount._instancesByContainerID[containerTag];
-    // if (prevComponent) {
-    //   var prevWrappedElement = prevComponent._currentElement;
-    //   var prevElement = prevWrappedElement.props;
-    //   if (shouldUpdateReactComponent(prevElement, nextElement)) {
-    //     ReactUpdateQueue.enqueueElementInternal(prevComponent, nextWrappedElement);
-    //     if (callback) {
-    //       ReactUpdateQueue.enqueueCallbackInternal(prevComponent, callback);
-    //     }
-    //     return prevComponent;
-    //   }
-    // }
-
-    var instance = instantiateReactComponent(nextWrappedElement);
-
-    if (process.env.NODE_ENV !== 'production') {
-      // Mute future events from the top level wrapper.
-      // It is an implementation detail that devtools should not know about.
-      instance._debugID = 0;
-
-      if (process.env.NODE_ENV !== 'production') {
-        ReactInstrumentation.debugTool.onBeginFlush();
-      }
-    }
+    var instance = instantiateReactComponent(nextWrappedElement, false);
 
     // The initial render is synchronous but any updates that happen during
     // rendering, in componentWillMount or componentDidMount, will be batched
@@ -116,11 +119,10 @@ var ReactHostMount = {
     if (process.env.NODE_ENV !== 'production') {
       // The instance here is TopLevelWrapper so we report mount for its child.
       ReactInstrumentation.debugTool.onMountRootComponent(instance._renderedComponent._debugID);
-      ReactInstrumentation.debugTool.onEndFlush();
     }
     return new ReactTestInstance(instance);
   }
 
 };
 
-module.exports = ReactHostMount;
+module.exports = ReactTestMount;

package/lib/ReactTestReconcileTransaction.js

@@ -16,6 +16,7 @@ var _assign = require('object-assign');
 var CallbackQueue = require('./CallbackQueue');
 var PooledClass = require('./PooledClass');
 var Transaction = require('./Transaction');
+var ReactUpdateQueue = require('./ReactUpdateQueue');
 
 /**
  * Provides a `CallbackQueue` queue for collecting `onDOMReady` callbacks during
@@ -83,6 +84,13 @@ var Mixin = {
     return this.reactMountReady;
   },
 
+  /**
+   * @return {object} The queue to collect React async events.
+   */
+  getUpdateQueue: function () {
+    return ReactUpdateQueue;
+  },
+
   /**
    * `PooledClass` looks for this, and will invoke this before allowing this
    * instance to be reused.

package/lib/ReactTestRenderer.js

@@ -15,6 +15,7 @@ var _assign = require('object-assign');
 
 function _objectWithoutProperties(obj, keys) { var target = {}; for (var i in obj) { if (keys.indexOf(i) >= 0) continue; if (!Object.prototype.hasOwnProperty.call(obj, i)) continue; target[i] = obj[i]; } return target; }
 
+var ReactComponentEnvironment = require('./ReactComponentEnvironment');
 var ReactDefaultBatchingStrategy = require('./ReactDefaultBatchingStrategy');
 var ReactEmptyComponent = require('./ReactEmptyComponent');
 var ReactMultiChild = require('./ReactMultiChild');
@@ -56,6 +57,11 @@ ReactTestComponent.prototype.receiveComponent = function (nextElement, transacti
   this.updateChildren(nextElement.props.children, transaction, context);
 };
 ReactTestComponent.prototype.getHostNode = function () {};
+ReactTestComponent.prototype.getPublicInstance = function () {
+  // I can't say this makes a ton of sense but it seems better than throwing.
+  // Maybe we'll revise later if someone has a good use case.
+  return null;
+};
 ReactTestComponent.prototype.unmountComponent = function () {};
 ReactTestComponent.prototype.toJSON = function () {
   var _currentElement$props = this._currentElement.props;
@@ -121,6 +127,11 @@ ReactEmptyComponent.injection.injectEmptyComponentFactory(function () {
   return new ReactTestEmptyComponent();
 });
 
+ReactComponentEnvironment.injection.injectEnvironment({
+  processChildrenUpdates: function () {},
+  replaceNodeWithMarkup: function () {}
+});
+
 var ReactTestRenderer = {
   create: ReactTestMount.render,
 

package/lib/ReactTestUtils.js

@@ -344,9 +344,11 @@ NoopInternalComponent.prototype = {
 
 var ShallowComponentWrapper = function (element) {
   // TODO: Consolidate with instantiateReactComponent
-  this._debugID = nextDebugID++;
-  var displayName = element.type.displayName || element.type.name || 'Unknown';
-  ReactInstrumentation.debugTool.onSetDisplayName(this._debugID, displayName);
+  if (process.env.NODE_ENV !== 'production') {
+    this._debugID = nextDebugID++;
+    var displayName = element.type.displayName || element.type.name || 'Unknown';
+    ReactInstrumentation.debugTool.onSetDisplayName(this._debugID, displayName);
+  }
 
   this.construct(element);
 };
@@ -424,6 +426,8 @@ function makeSimulator(eventType) {
 
     var fakeNativeEvent = new Event();
     fakeNativeEvent.target = node;
+    fakeNativeEvent.type = eventType.toLowerCase();
+
     // 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, ReactDOMComponentTree.getInstanceFromNode(node), fakeNativeEvent, node);

package/lib/ReactTransitionGroup.js

@@ -236,6 +236,7 @@ var ReactTransitionGroup = React.createClass({
     delete props.childFactory;
     delete props.transitionLeaveTimeout;
     delete props.transitionEnterTimeout;
+    delete props.transitionAppearTimeout;
     delete props.component;
 
     return React.createElement(this.props.component, props, childrenToRender);

package/lib/ReactUpdateQueue.js

@@ -42,10 +42,11 @@ function getInternalInstanceReadyForUpdate(publicInstance, callerName) {
   var internalInstance = ReactInstanceMap.get(publicInstance);
   if (!internalInstance) {
     if (process.env.NODE_ENV !== 'production') {
+      var ctor = publicInstance.constructor;
       // 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.
-      process.env.NODE_ENV !== '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) : void 0;
+      process.env.NODE_ENV !== '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, ctor && (ctor.displayName || ctor.name) || 'ReactClass') : void 0;
     }
     return null;
   }
@@ -209,8 +210,10 @@ var ReactUpdateQueue = {
     enqueueUpdate(internalInstance);
   },
 
-  enqueueElementInternal: function (internalInstance, newElement) {
-    internalInstance._pendingElement = newElement;
+  enqueueElementInternal: function (internalInstance, nextElement, nextContext) {
+    internalInstance._pendingElement = nextElement;
+    // TODO: introduce _pendingContext instead of setting it directly.
+    internalInstance._context = nextContext;
     enqueueUpdate(internalInstance);
   },
 

package/lib/ReactUpdates.js

@@ -17,7 +17,6 @@ var _prodInvariant = require('./reactProdInvariant'),
 var CallbackQueue = require('./CallbackQueue');
 var PooledClass = require('./PooledClass');
 var ReactFeatureFlags = require('./ReactFeatureFlags');
-var ReactInstrumentation = require('./ReactInstrumentation');
 var ReactReconciler = require('./ReactReconciler');
 var Transaction = require('./Transaction');
 
@@ -164,10 +163,6 @@ function runBatchedUpdates(transaction) {
 }
 
 var flushBatchedUpdates = function () {
-  if (process.env.NODE_ENV !== 'production') {
-    ReactInstrumentation.debugTool.onBeginFlush();
-  }
-
   // 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
@@ -187,10 +182,6 @@ var flushBatchedUpdates = function () {
       CallbackQueue.release(queue);
     }
   }
-
-  if (process.env.NODE_ENV !== 'production') {
-    ReactInstrumentation.debugTool.onEndFlush();
-  }
 };
 
 /**
@@ -203,7 +194,7 @@ function enqueueUpdate(component) {
   // 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
+  // function, like setState, forceUpdate, etc.; creation and
   // destruction of top-level components is guarded in ReactMount.)
 
   if (!batchingStrategy.isBatchingUpdates) {

package/lib/ReactVersion.js

@@ -11,4 +11,4 @@
 
 'use strict';
 
-module.exports = '15.2.0';
+module.exports = '15.3.0-rc.3';

package/lib/ResponderEventPlugin.js

@@ -438,7 +438,7 @@ var ResponderEventPlugin = {
       !(trackedTouchCount >= 0) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Ended a touch event which was not counted in trackedTouchCount.') : _prodInvariant('132') : void 0;
     }
 
-    ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent, nativeEventTarget);
+    ResponderTouchHistoryStore.recordTouchTrack(topLevelType, nativeEvent);
 
     var extracted = canTriggerTransfer(topLevelType, targetInst, nativeEvent) ? setResponderAndExtractTransfer(topLevelType, targetInst, nativeEvent, nativeEventTarget) : null;
     // Responder may or may not have transferred on a new touch start/move.

package/lib/ResponderTouchHistoryStore.js

@@ -7,6 +7,7 @@
  * of patent rights can be found in the PATENTS file in the same directory.
  *
  * @providesModule ResponderTouchHistoryStore
+ * 
  */
 
 'use strict';
@@ -16,30 +17,22 @@ var _prodInvariant = require('./reactProdInvariant');
 var EventPluginUtils = require('./EventPluginUtils');
 
 var invariant = require('fbjs/lib/invariant');
+var warning = require('fbjs/lib/warning');
 
+var isEndish = EventPluginUtils.isEndish;
 var isMoveish = EventPluginUtils.isMoveish;
 var isStartish = EventPluginUtils.isStartish;
-var isEndish = EventPluginUtils.isEndish;
-
-var MAX_TOUCH_BANK = 20;
 
 /**
- * Touch position/time tracking information by touchID. Typically, we'll only
- * see IDs with a range of 1-20 (they are recycled when touches end and then
- * start again). This data is commonly needed by many different interaction
- * logic modules so precomputing it is very helpful to do once.
- * Each touch object in `touchBank` is of the following form:
- * { touchActive: boolean,
- *   startTimeStamp: number,
- *   startPageX: number,
- *   startPageY: number,
- *   currentPageX: number,
- *   currentPageY: number,
- *   currentTimeStamp: number
- * }
+ * Tracks the position and time of each active touch by `touch.identifier`. We
+ * should typically only see IDs in the range of 1-20 because IDs get recycled
+ * when touches end and start again.
  */
+
+var MAX_TOUCH_BANK = 20;
+var touchBank = [];
 var touchHistory = {
-  touchBank: [],
+  touchBank: touchBank,
   numberActiveTouches: 0,
   // If there is only one active touch, we remember its location. This prevents
   // us having to loop through all of the touches all the time in the most
@@ -48,24 +41,23 @@ var touchHistory = {
   mostRecentTimeStamp: 0
 };
 
-var timestampForTouch = function (touch) {
+function timestampForTouch(touch) {
   // The legacy internal implementation provides "timeStamp", which has been
   // renamed to "timestamp". Let both work for now while we iron it out
   // TODO (evv): rename timeStamp to timestamp in internal code
   return touch.timeStamp || touch.timestamp;
-};
+}
 
 /**
  * TODO: Instead of making gestures recompute filtered velocity, we could
  * include a built in velocity computation that can be reused globally.
- * @param {Touch} touch Native touch object.
  */
-var initializeTouchData = function (touch) {
+function createTouchRecord(touch) {
   return {
     touchActive: true,
-    startTimeStamp: timestampForTouch(touch),
     startPageX: touch.pageX,
     startPageY: touch.pageY,
+    startTimeStamp: timestampForTouch(touch),
     currentPageX: touch.pageX,
     currentPageY: touch.pageY,
     currentTimeStamp: timestampForTouch(touch),
@@ -73,91 +65,101 @@ var initializeTouchData = function (touch) {
     previousPageY: touch.pageY,
     previousTimeStamp: timestampForTouch(touch)
   };
-};
-
-var reinitializeTouchTrack = function (touchTrack, touch) {
-  touchTrack.touchActive = true;
-  touchTrack.startTimeStamp = timestampForTouch(touch);
-  touchTrack.startPageX = touch.pageX;
-  touchTrack.startPageY = touch.pageY;
-  touchTrack.currentPageX = touch.pageX;
-  touchTrack.currentPageY = touch.pageY;
-  touchTrack.currentTimeStamp = timestampForTouch(touch);
-  touchTrack.previousPageX = touch.pageX;
-  touchTrack.previousPageY = touch.pageY;
-  touchTrack.previousTimeStamp = timestampForTouch(touch);
-};
-
-var validateTouch = function (touch) {
-  var identifier = touch.identifier;
-  !(identifier != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch object is missing identifier') : _prodInvariant('133') : void 0;
-  if (identifier > MAX_TOUCH_BANK) {
-    console.warn('Touch identifier ' + identifier + ' is greater than maximum ' + 'supported ' + MAX_TOUCH_BANK + ' which causes performance issues ' + 'backfilling array locations for all of the indices.');
-  }
-};
-
-var recordStartTouchData = function (touch) {
-  var touchBank = touchHistory.touchBank;
-  var identifier = touch.identifier;
-  var touchTrack = touchBank[identifier];
-  if (process.env.NODE_ENV !== 'production') {
-    validateTouch(touch);
-  }
-  if (touchTrack) {
-    reinitializeTouchTrack(touchTrack, touch);
+}
+
+function resetTouchRecord(touchRecord, touch) {
+  touchRecord.touchActive = true;
+  touchRecord.startPageX = touch.pageX;
+  touchRecord.startPageY = touch.pageY;
+  touchRecord.startTimeStamp = timestampForTouch(touch);
+  touchRecord.currentPageX = touch.pageX;
+  touchRecord.currentPageY = touch.pageY;
+  touchRecord.currentTimeStamp = timestampForTouch(touch);
+  touchRecord.previousPageX = touch.pageX;
+  touchRecord.previousPageY = touch.pageY;
+  touchRecord.previousTimeStamp = timestampForTouch(touch);
+}
+
+function getTouchIdentifier(_ref) {
+  var identifier = _ref.identifier;
+
+  !(identifier != null) ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch object is missing identifier.') : _prodInvariant('138') : void 0;
+  process.env.NODE_ENV !== 'production' ? warning(identifier <= MAX_TOUCH_BANK, 'Touch identifier %s is greater than maximum supported %s which causes ' + 'performance issues backfilling array locations for all of the indices.', identifier, MAX_TOUCH_BANK) : void 0;
+  return identifier;
+}
+
+function recordTouchStart(touch) {
+  var identifier = getTouchIdentifier(touch);
+  var touchRecord = touchBank[identifier];
+  if (touchRecord) {
+    resetTouchRecord(touchRecord, touch);
   } else {
-    touchBank[touch.identifier] = initializeTouchData(touch);
+    touchBank[identifier] = createTouchRecord(touch);
   }
   touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-};
-
-var recordMoveTouchData = function (touch) {
-  var touchBank = touchHistory.touchBank;
-  var touchTrack = touchBank[touch.identifier];
-  if (process.env.NODE_ENV !== 'production') {
-    validateTouch(touch);
-    !touchTrack ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch data should have been recorded on start') : _prodInvariant('134') : void 0;
+}
+
+function recordTouchMove(touch) {
+  var touchRecord = touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = true;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.error('Cannot record touch move without a touch start.\n' + 'Touch Move: %s\n', 'Touch Bank: %s', printTouch(touch), printTouchBank());
   }
-  touchTrack.touchActive = true;
-  touchTrack.previousPageX = touchTrack.currentPageX;
-  touchTrack.previousPageY = touchTrack.currentPageY;
-  touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
-  touchTrack.currentPageX = touch.pageX;
-  touchTrack.currentPageY = touch.pageY;
-  touchTrack.currentTimeStamp = timestampForTouch(touch);
-  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-};
-
-var recordEndTouchData = function (touch) {
-  var touchBank = touchHistory.touchBank;
-  var touchTrack = touchBank[touch.identifier];
-  if (process.env.NODE_ENV !== 'production') {
-    validateTouch(touch);
-    !touchTrack ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Touch data should have been recorded on start') : _prodInvariant('134') : void 0;
+}
+
+function recordTouchEnd(touch) {
+  var touchRecord = touchBank[getTouchIdentifier(touch)];
+  if (touchRecord) {
+    touchRecord.touchActive = false;
+    touchRecord.previousPageX = touchRecord.currentPageX;
+    touchRecord.previousPageY = touchRecord.currentPageY;
+    touchRecord.previousTimeStamp = touchRecord.currentTimeStamp;
+    touchRecord.currentPageX = touch.pageX;
+    touchRecord.currentPageY = touch.pageY;
+    touchRecord.currentTimeStamp = timestampForTouch(touch);
+    touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
+  } else {
+    console.error('Cannot record touch end without a touch start.\n' + 'Touch End: %s\n', 'Touch Bank: %s', printTouch(touch), printTouchBank());
   }
-  touchTrack.previousPageX = touchTrack.currentPageX;
-  touchTrack.previousPageY = touchTrack.currentPageY;
-  touchTrack.previousTimeStamp = touchTrack.currentTimeStamp;
-  touchTrack.currentPageX = touch.pageX;
-  touchTrack.currentPageY = touch.pageY;
-  touchTrack.currentTimeStamp = timestampForTouch(touch);
-  touchTrack.touchActive = false;
-  touchHistory.mostRecentTimeStamp = timestampForTouch(touch);
-};
+}
+
+function printTouch(touch) {
+  return JSON.stringify({
+    identifier: touch.identifier,
+    pageX: touch.pageX,
+    pageY: touch.pageY,
+    timestamp: timestampForTouch(touch)
+  });
+}
+
+function printTouchBank() {
+  var printed = JSON.stringify(touchBank.slice(0, MAX_TOUCH_BANK));
+  if (touchBank.length > MAX_TOUCH_BANK) {
+    printed += ' (original size: ' + touchBank.length + ')';
+  }
+  return printed;
+}
 
 var ResponderTouchHistoryStore = {
   recordTouchTrack: function (topLevelType, nativeEvent) {
-    var touchBank = touchHistory.touchBank;
     if (isMoveish(topLevelType)) {
-      nativeEvent.changedTouches.forEach(recordMoveTouchData);
+      nativeEvent.changedTouches.forEach(recordTouchMove);
     } else if (isStartish(topLevelType)) {
-      nativeEvent.changedTouches.forEach(recordStartTouchData);
+      nativeEvent.changedTouches.forEach(recordTouchStart);
       touchHistory.numberActiveTouches = nativeEvent.touches.length;
       if (touchHistory.numberActiveTouches === 1) {
         touchHistory.indexOfSingleActiveTouch = nativeEvent.touches[0].identifier;
       }
     } else if (isEndish(topLevelType)) {
-      nativeEvent.changedTouches.forEach(recordEndTouchData);
+      nativeEvent.changedTouches.forEach(recordTouchEnd);
       touchHistory.numberActiveTouches = nativeEvent.touches.length;
       if (touchHistory.numberActiveTouches === 1) {
         for (var i = 0; i < touchBank.length; i++) {
@@ -168,14 +170,14 @@ var ResponderTouchHistoryStore = {
           }
         }
         if (process.env.NODE_ENV !== 'production') {
-          var activeTouchData = touchBank[touchHistory.indexOfSingleActiveTouch];
-          var foundActive = activeTouchData != null && !!activeTouchData.touchActive;
-          !foundActive ? process.env.NODE_ENV !== 'production' ? invariant(false, 'Cannot find single active touch') : _prodInvariant('135') : void 0;
+          var activeRecord = touchBank[touchHistory.indexOfSingleActiveTouch];
+          process.env.NODE_ENV !== 'production' ? warning(activeRecord != null && activeRecord.touchActive, 'Cannot find single active touch.') : void 0;
         }
       }
     }
   },
 
+
   touchHistory: touchHistory
 };