Does a shallow comparison for props and state.
See ReactComponentWithPureRenderMixin
430606
function shallowCompare(instance, nextProps, nextState) {
  return (
    !shallowEqual(instance.props, nextProps) ||
    !shallowEqual(instance.state, nextState)
  );
}
612941
function checkComponentDefined (el, name) {
  // Check if element contains the component.
  if (el.components[name] && el.components[name].attrValue) { return true; }

  return isComponentMixedIn(name, el.mixinEls);
}
88606
function() {
        var checkedState = this.dataModel.getCheckedState();
        var $input, props;

        $input = this._getHeaderMainCheckbox();
        if (!$input.length) {
            return;
        }

        if (!checkedState.available) {
            props = {
                checked: false,
                disabled: true
            };
        } else {
            props = {
                checked: checkedState.available === checkedState.checked,
                disabled: false
            };
        }
        $input.prop(props);
    }
106698
function ReactResolver$$1(component) {
  return isReactComponent(component) ? component : function (props) {
    return React.createElement(VueContainer, _extends({}, props, { component: component }));
  };
}
122171
function(props) {
    return function (obj1, obj2) {
      var i = 0, result = 0, numberOfProperties = props.length;
      while(result === 0 && i < numberOfProperties) {
        result = dynamicSort(props[i])(obj1, obj2);
        i++;
      }
      return result;
    }
  }
121364
def getComponentState(self, pchRenderModelName, pchComponentName):
        """"""

        fn = self.function_table.getComponentState
        pControllerState = VRControllerState_t()
        pState = RenderModel_ControllerMode_State_t()
        pComponentState = RenderModel_ComponentState_t()
        result = fn(pchRenderModelName, pchComponentName, byref(pControllerState), byref(pState), byref(pComponentState))
        return result, pControllerState, pState, pComponentState
1008549
function processInitState(state, action) {
    const { data, persistState, path } = action.payload;
    const pathItems = path.split("/");
    const doNotReplace = persistState;
    const hasData = objectPath.has(state, pathItems);
    if (hasData) {
        if (doNotReplace) {
            // --- has initialised
            // --- force component.state to refresh
            const existingData = objectPath.get(state, pathItems);
            return objectPathImmutable.merge(state, pathItems, existingData);
        }
    }
    return objectPathImmutable.merge(state, pathItems, data);
}
567567
function diffDataProps(props, oldProps) {
  if (oldProps === null) {
    return 'oldProps is null, initial diff';
  }

  // Support optional app defined comparison of data
  const {dataComparator} = props;
  if (dataComparator) {
    if (!dataComparator(props.data, oldProps.data)) {
      return 'Data comparator detected a change';
    }
    // Otherwise, do a shallow equal on props
  } else if (props.data !== oldProps.data) {
    return 'A new data container was supplied';
  }

  return null;
}
928515
function FormWithSingleInputAndButton({
  formProps,
  inputProps,
  buttonProps,
}: Props): React.Node {
  const button = React.createElement(Button, buttonProps);
  return (
    <Form {...formProps}>
      <Form.InputGroup inputProps={inputProps} append={button} />
    </Form>
  );
}
977026
function observer (componentClass) {
  if (typeof componentClass === 'function' &&
    (!componentClass.prototype || !componentClass.prototype.render) && !componentClass.isReactClass && !React.Component.isPrototypeOf(componentClass)
  ) {
    var ObserverComponent = (function (superclass) {
      function ObserverComponent () {
        superclass.apply(this, arguments);
      }

      if ( superclass ) ObserverComponent.__proto__ = superclass;
      ObserverComponent.prototype = Object.create( superclass && superclass.prototype );
      ObserverComponent.prototype.constructor = ObserverComponent;

      ObserverComponent.prototype.render = function render () {
        return componentClass.call(this, this.props, this.context)
      };

      return ObserverComponent;
    }(React.Component));
    ObserverComponent.displayName = componentClass.displayName || componentClass.name;
    ObserverComponent.contextTypes = componentClass.contextTypes;
    ObserverComponent.propTypes = componentClass.propTypes;
    ObserverComponent.defaultProps = componentClass.defaultProps;
    return observer(ObserverComponent)
  }

  if (!componentClass) {
    throw new Error("Please pass a valid component to 'observer'")
  }

  var target = componentClass.prototype || componentClass;
  mixinLifecycleEvents(target);
  return componentClass
}
602639
function (rootComp, reactContext) {
      var ctx = this;

      var effectiveReactContext = reactContext || {};
      effectiveReactContext.morearty = ctx;

      return React.createClass({
        displayName: 'Bootstrap',

        childContextTypes: {
          morearty: React.PropTypes.instanceOf(Context).isRequired
        },

        getChildContext: function () {
          return effectiveReactContext;
        },

        componentWillMount: function () {
          ctx.init(this);
        },

        render: function () {
          var effectiveProps = Util.assign({}, {binding: ctx.getBinding()}, this.props);

          return React.createFactory(rootComp)(effectiveProps);
        }
      });
    }
44671
function babelReactResolver$$1(component, props, children) {
  return isReactComponent(component) ? React.createElement(component, props, children) : React.createElement(VueContainer, Object.assign({ component: component }, props), children);
}
299700
function () {
        var compo = $singleton (Component, {
                        somthingHappened: $triggerOnce () })

        $assertEveryCalled (function (first, second) {
            compo.somthingHappened (function (what) { $assert (what, 'somthin'); first () })
            compo.somthingHappened (function (what) { $assert (what, 'somthin'); second () })
            compo.somthingHappened ('somthin') }) }
322903
public static boolean isRendered(FacesContext facesContext,
            UIComponent uiComponent)
    {
        // We must call pushComponentToEL here because ValueExpression may have 
        // implicit object "component" used. 
        try
        {
            uiComponent.pushComponentToEL(facesContext, uiComponent);
            return uiComponent.isRendered();
        }
        finally
        {
            uiComponent.popComponentFromEL(facesContext);
        }
    }
1295997
def deep_compare(self, other, settings):
        

        if not self._is_compatible_with(other):
            return False

        first, middle, last = self._compare_components(other, settings)

        return first and middle and last
548350
function normalizeComponents (to, ___) {
  flatMapComponents(to, (Component, _, match, key) => {
    if (typeof Component === 'object' && !Component.options) {
      // Updated via vue-router resolveAsyncComponents()
      Component = Vue.extend(Component)
      Component._Ctor = Component
      match.components[key] = Component
    }
    return Component
  })
}
419953
function (nextProps, nextState) {
            return nextProps.forceRender ||
                this.props.entry !== nextProps.entry ||
                this.props.extensions !== nextProps.extensions;
        }