How to use element-resize-event - 10 common examples

componentDidMount() {
    let onEvents = this.props.onEvents || {}
    this.renderGLDom(glObj => glObj.resize())

    //this.bindEvents(glObj, onEvents)

    // on resize
    elementResizeEvent(this.refs.webglDom, () => {
      this.renderGLDom(glObj => glObj.resize())
    })
  }

public componentDidMount() {
      if (!this.containerRef) {
        throw new Error('Cannot find container div');
      }

      this.updateDimensions();
      if (elementResize) {
        // Experimental: `element-resize-event` fires when an element resizes.
        // It attaches its own window resize listener and also uses
        // requestAnimationFrame, so we can just call `this.updateDimensions`.
        onElementResize(this.containerRef, this.updateDimensions);
      } else {
        this.getWindow().addEventListener('resize', this.onResize, false);
      }
    }

componentWillUnmount() {
    // Remove in event listeners for the container
    // Pending; https://github.com/KyleAMathews/element-resize-event/issues/2
    if (removeResizeListener) {
      removeResizeListener(this.container, this._resizedContainer);
    }

    // Remove the map instance through the API
    if (this._map) {
      this._map.remove();
      this._map = null;
    }
  }

// If we have a next viewport action
    if (updateMapViewport) {
      this._updateMapViewport({}, updateMapViewport);
    }

    // Initial actions
    this._updateConvenienceHandlers({}, this.props);
    this._updateMapOptions({}, this.props);
    this._updateFeatureState({}, this.props);

    // Listen to some of the dispatched events
    this._listenStateEvents();

    // Add in event listeners for the container
    elementResizedEvent(this.container, this._resizedContainer);
  }

componentDidMount() {
    const element = this.wrapperRef.current;
    this.updateSize();
    elementResizeEvent(element, this.updateSize);
  }
  componentWillUnmount() {

componentDidMount() {
    const { wrapper, content } = this.refs;
    const actualContent = content.children[0];

    this.updateState({
      ...this.state,
      contentSize: { width: actualContent.offsetWidth, height: actualContent.offsetHeight },
      wrapperSize: { width: wrapper.offsetWidth, height: wrapper.offsetHeight },
    });

    ere(actualContent, () => {
      this.updateState({
        ...this.state,
        contentSize: { width: actualContent.offsetWidth, height: actualContent.offsetHeight },
      });
    });

    ere(wrapper, () => {
      this.updateState({
        ...this.state,
        wrapperSize: { width: wrapper.offsetWidth, height: wrapper.offsetHeight },
      });
    });
  }

componentDidMount() {
    let chartObj = this.renderEChart();
    for (let event in this.props.bindEvents) {
      if (typeof event === 'string' && typeof bindEvents[event] === 'function') {
        chartObj.on(event, (params) => {
          bindEvents[event](params, chartObj);
        });
      }
    }
    elementResizeEvent(this.refs.chart, () => {
      chartObj.resize();
    });
  }
  componentDidUpdate() {

initializeCustomComponents({
      customProps,
      CustomTableBodyCell,
      CustomTableBodyRow,
      CustomTableHeaderCell,
      CustomTableHeaderRow,
      customDataTypes
    });

    initText(text);
    updateComponentSize();

    const callBack = () => throttle(() => updateComponentSize(), 100);
    const element = document.getElementById("o2xp").parentElement;

    elementResizeEvent(element, callBack());
  }

componentDidMount() {
    this.setVidzInstance();

    elementResize(this.refs.container, this.debounceSetPlayerDimensions);

    document.addEventListener(fullscreenchange, this.onFullscreenChange);
    window.addEventListener('resize', this.debounceSetPlayerDimensionsOnResize);
  }

useEffect(() => {
    const updateSize = () => {
      const element = wrapperRef.current;
      setSize({ height: element.clientHeight, width: element.clientWidth });
    };
    const element = wrapperRef.current;
    updateSize();
    elementResizeEvent(element, updateSize);
    return () => elementResizeEvent.unbind(wrapperRef.current);
  }, []);
  return [size, wrapperRef];