How to use react-fast-compare - 10 common examples

console.warn(
        '`useDeepCompareEffect` should not be used with no dependencies. Use React.useEffect instead.'
      )
    }

    if (deps.every(isPrimitive)) {
      // eslint-disable-next-line no-console
      console.warn(
        '`useDeepCompareEffect` should not be used with dependencies that are all primitive values. Use React.useEffect instead.'
      )
    }
  }

  const ref = useRef(undefined)

  if (!isEqual(deps, ref.current)) {
    ref.current = deps
  }

  useEffect(effect, ref.current)
}

{
          target: "parent",
          mutation: () => {
            return {
              isSelecting: true,
              domainBox,
              fullDomainBox,
              cachedBrushDomain: brushDomain,
              currentDomain,
              parentSVG,
              ...this.getResizeMutation(domainBox, activeHandles)
            };
          }
        }
      ];
    } else if (this.withinBounds({ x, y }, domainBox) && !isEqual(domain, currentDomain)) {
      // if the event occurs within a selected region start a panning event, unless the whole
      // domain is selected
      return [
        {
          target: "parent",
          mutation: () => ({
            isPanning: allowDrag,
            startX: x,
            startY: y,
            domainBox,
            fullDomainBox,
            currentDomain,
            cachedBrushDomain: brushDomain,
            parentSVG,
            ...domainBox // set x1, x2, y1, y2
          })

componentDidUpdate (prevProps) {
    // If there was a change in commands, re-validate
    if (!isEqual(prevProps.commands, this.props.commands)) this.validateCommands()
  }

static getDerivedStateFromProps(
    nextProps: SelectableProps,
    prevState: SelectableState
  ): $Shape | null {
    if (
      nextProps.selected !== undefined &&
      !deepEqual(nextProps.selected, prevState.selected)
    ) {
      return {
        selected: nextProps.selected
      };
    }

    return null; // no change
  }

shouldComponentUpdate(nextProps: TableHeaderRowProps) {
    return !deepEqual(this.props, nextProps);
  }

]).then(([fieldErrors, schemaErrors, validateErrors]) => {
          const combinedErrors = deepmerge.all>(
            [fieldErrors, schemaErrors, validateErrors],
            { arrayMerge }
          );
          if (!isEqual(state.errors, combinedErrors)) {
            dispatch({ type: 'SET_ERRORS', payload: combinedErrors });
          }
          dispatch({ type: 'SET_ISVALIDATING', payload: false });
          return combinedErrors;
        });
      } else {

const arePropsEqual = (prev, next) =>
  prev.isEmpty === next.isEmpty &&
  prev.isWalletEthZero === next.isWalletEthZero &&
  prev.sections.length === next.sections.length &&
  isEqual(prev.sections, next.sections);

shouldComponentUpdate(nextProps: Props, _): boolean {
    return !isEqual(this.props.nodes, nextProps.nodes) || !isEqual(this.props.edges, nextProps.edges)
  }

public shouldComponentUpdate(nextProps: Props) {
    return !isEqual(nextProps, this.props);
  }
}

shouldComponentUpdate(nextProps, nextState) {
    const equalProps = isEqual(this.props, nextProps);
    if (this.props.animate && !equalProps) {
      this.setAnimationState(this.props, nextProps);
    }
    this.events = Wrapper.getAllEvents(nextProps);
    return this.props.animate || !equalProps || !isEqual(this.state, nextState);
  }