react-scroll-to-bottom-updated/lib/esm/EventSpy.js

React container that will auto scroll to bottom

import _Date$now from "@babel/runtime-corejs3/core-js-stable/date/now";
import "core-js/modules/es.function.name.js";
import { useCallback, useLayoutEffect, useMemo, useRef } from 'react';
import debounceFn from './debounce';

var EventSpy = function EventSpy(_ref) {
  var _ref$debounce = _ref.debounce,
      debounce = _ref$debounce === void 0 ? 200 : _ref$debounce,
      name = _ref.name,
      onEvent = _ref.onEvent,
      target = _ref.target;
  // We need to save the "onEvent" to ref.
  // This is because "onEvent" may change from time to time, but debounce may still fire to the older callback.
  var onEventRef = useRef();
  onEventRef.current = onEvent;
  var debouncer = useMemo(function () {
    return debounceFn(function (event) {
      var current = onEventRef.current;
      current && current(event);
    }, debounce);
  }, [debounce, onEventRef]);
  var handleEvent = useCallback(function (event) {
    event.timeStampLow = _Date$now();
    debouncer(event);
  }, [debouncer]);
  useLayoutEffect(function () {
    target.addEventListener(name, handleEvent, {
      passive: true
    });
    handleEvent({
      target: target,
      type: name
    });
    return function () {
      return target.removeEventListener(name, handleEvent);
    };
  }, [name, handleEvent, target]);
  return false;
};

export default EventSpy;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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