How to use shallowequal - 10 common examples

shouldComponentUpdate(nextProps) {
      const { state } = this.props.navigation;
      const { state: nextState } = nextProps.navigation;

      // This is a result of a previous `setOptions` call, prevent extra render
      if (state.params) {
        if (
          nextState.params &&
          nextState.params[COUNT_PARAM] === state.params[COUNT_PARAM] + 1
        ) {
          return false;
        }
      }

      return (
        !shallowEqual(this.props, nextProps) ||
        !shallowEqual(this.state, nextState)
      );
    }

value: function componentWillReceiveProps(nextProps) {
      var _this2 = this;

      if (!('value' in nextProps || 'min' in nextProps || 'max' in nextProps)) return;
      if (this.props.min === nextProps.min && this.props.max === nextProps.max && shallowEqual(this.props.value, nextProps.value)) {
        return;
      }
      var bounds = this.state.bounds;

      var value = nextProps.value || bounds;
      var nextBounds = value.map(function (v) {
        return _this2.trimAlignValue(v, nextProps);
      });
      if (nextBounds.length === bounds.length && nextBounds.every(function (v, i) {
        return v === bounds[i];
      })) return;

      this.setState({ bounds: nextBounds });
      if (bounds.some(function (v) {
        return utils.isValueOutOfRange(v, nextProps);
      })) {

},
    } = props;
    const { toolbarTitle } = state.drawer;

    const ids = ['docgens', section, component].filter(id => !!id);
    const docgens = get(state, ids.join('.'), null);

    const nextResult = {
      component,
      section,
      docgens,
      toolbarTitle,
      mobile: state.media.mobile,
      ...actions,
    };
    if (!shallowEqual(result, nextResult)) {
      result = nextResult;
    }

    return result;
  };
})(PropTypesPage);

shouldComponentUpdate (prevProps) {
    if (!shallowEqual(prevProps.state, this.props.state) ||
      !shallowEqual(prevProps.path, this.props.path) ||
      !shallowEqual(prevProps.item, this.props.item)) {
      return true
    }
    return false
  }

const dataUpdate = {};
                    const layoutUpdate = {};
                    let dataUpdateTraces = 0;
                    const newXOptions = getXAxisOptions(newParams);
                    const newYOptions = getYAxisOptions(newParams);
                    const oldXOptions = getXAxisOptions(params);
                    const oldYOptions = getYAxisOptions(params);

                    if (newDesc !== desc) {
                         layoutUpdate['title'] =  newDesc;
                         if (!newDesc || !desc) {
                             layoutUpdate['margin.t'] = (newXOptions.xOpposite ? X_TICKLBL_PX : MIN_MARGIN_PX)+(newDesc ? TITLE_PX: 0);
                         }
                     }

                    if (!shallowequal(oldXOptions, newXOptions)) {
                        layoutUpdate['xaxis.title'] = newXOptions.xTitle;
                        layoutUpdate['xaxis.showgrid'] = newXOptions.xGrid;
                        layoutUpdate['xaxis.side'] = newXOptions.xOpposite ? 'top' : 'bottom';
                        layoutUpdate['xaxis.type'] = newXOptions.xLog ? 'log' : 'linear';
                        layoutUpdate['margin.b'] = newXOptions.xOpposite ? MIN_MARGIN_PX : X_TICKLBL_PX;
                        layoutUpdate['margin.t'] = (newXOptions.xOpposite ? X_TICKLBL_PX : MIN_MARGIN_PX)+(newDesc ? TITLE_PX: 0);
                    }
                    if (!shallowequal(oldYOptions, newYOptions)) {
                        layoutUpdate['yaxis.title'] = newYOptions.yTitle;
                        layoutUpdate['yaxis.showgrid'] = newYOptions.yGrid;
                        layoutUpdate['yaxis.type'] = newYOptions.yLog ? 'log' : 'linear';
                        if (oldYOptions.yOpposite !== newYOptions.yOpposite) {
                            layoutUpdate['yaxis.side'] = newYOptions.yOpposite ? 'right' : 'left';
                            layoutUpdate['yaxis.tickprefix'] = newYOptions.yOpposite ? '' : '  ',
                            layoutUpdate['yaxis.ticksuffix'] = newYOptions.yOpposite ? '  ' : '',
                            layoutUpdate['margin.l'] = newYOptions.yOpposite ? MIN_MARGIN_PX : Y_TICKLBL_PX;

return (state) => {
    const { rateLimits } = state.github;

    const nextResult = { ...actions, rateLimits };
    if (!shallowEqual(result, nextResult)) {
      result = nextResult;
    }

    return result;
  };
})(AboutRateLimiting);

const compareProps = (nextProps, currentProps, additionalIgnore = {}) => (
    shallowequal({...nextProps, ...ignoredProps, ...additionalIgnore}, {...currentProps, ...ignoredProps, ...additionalIgnore})
    && deeperProps.reduce((acc, line) => acc && shallowequal(nextProps[line], currentProps[line]), true)
  );

});
          const newRequestedQueries = stableMap(
            declaredQueries,
            ({ name, params }, key) => {
              const query = queries[key];
              if (query && doNotCreate[query.id]) {
                return query.id;
              }
              return dispatch(
                queryRequest(name, params, {
                  socketId: connection.id,
                }),
              );
            },
          );
          if (!shallowEqual(newRequestedQueries, requestedQueries)) {
            setRequestedQueries(newRequestedQueries);
          }
        };
      },

shouldComponentUpdate (nextProps: Props, nextState: any): boolean {
    return !shallowEqual(this.props, nextProps, (obj, oth, key) => {
      if (['style', 'followingMap'].includes(key)) {
        return shallowEqual(obj, oth)
      }
      if (key === 'metaDataMap') {
        return I.is(obj, oth)
      }
      return undefined
    })
  }

componentWillReceiveProps(nextProps) {
    if (!shallowEqual(nextProps.showStartIndex, this.props.showStartIndex)) {
      this.sizeManager.update({
        _showStartIndex: nextProps.showStartIndex
      });
    }
    if (!shallowEqual(nextProps.rowSelection, this.props.rowSelection)) {
      this.selectManager.updateSelection(nextProps.rowSelection);
    }
    if (!shallowEqual(nextProps.dataSource, this.props.dataSource)) {
      this.dataManager.reset(nextProps.dataSource);
      const dh = this.sizeManager._dataHeight;
      this.selectManager.count = this.selectManager.getKeys(
        this.dataManager.getData()
      ).length;
      this.sizeManager.update({
        _dataHeight: this.dataManager._bodyHeight,
        _dataEmpty: this.dataManager.isEmpty()
      });
      if (dh !== 0 && this.sizeManager._dataHeight === 0) {
        this.sizeManager.update({_scrollTop: 0});
        this.updateScrollTop({scrollTop: 0});
      }
      if (
        nextProps.pullDown &&
        dh < this.sizeManager._dataHeight &&