@gdjiami/hooks/ie8/usePoll.js

react hooks for mygzb.com

import _regeneratorRuntime from "@babel/runtime/regenerator";
import { useState, useCallback } from 'react';
import useRefProps from './useRefProps';
import useRefState from './useRefState';
import useOnUnmount from './useOnUnmount';
import useInstance from './useInstance';
import { useOnUpdate } from './useOnUpdate';
/**
 * 实现页面轮询机制
 */

export default function usePoll(options) {
  var _useRefState = useRefState(false),
      polling = _useRefState[0],
      setPolling = _useRefState[1],
      pollingRef = _useRefState[2];

  var _useState = useState(),
      error = _useState[0],
      setError = _useState[1];

  var _useInstance = useInstance({}),
      state = _useInstance[0];

  var optionsRef = useRefProps(options);
  var poll = useCallback(function _callee2(immediate) {
    return _regeneratorRuntime.async(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            if (!(state.unmounted || pollingRef.current)) {
              _context2.next = 2;
              break;
            }

            return _context2.abrupt("return");

          case 2:
            setPolling(true);
            state.timer = window.setTimeout(function _callee() {
              var res, _error;

              return _regeneratorRuntime.async(function _callee$(_context) {
                while (1) {
                  switch (_context.prev = _context.next) {
                    case 0:
                      if (!state.unmounted) {
                        _context.next = 2;
                        break;
                      }

                      return _context.abrupt("return");

                    case 2:
                      _context.prev = 2;
                      setError(undefined);
                      _context.prev = 4;
                      _context.next = 7;
                      return _regeneratorRuntime.awrap(optionsRef.current.poller());

                    case 7:
                      res = _context.sent;
                      _context.next = 18;
                      break;

                    case 10:
                      _context.prev = 10;
                      _context.t0 = _context["catch"](4);
                      console.warn("[usePoll] poll error", _context.t0);
                      _error = _context.t0;
                      setError(_context.t0);

                      if (optionsRef.current.onError) {
                        optionsRef.current.onError(_context.t0);
                      }

                      if (optionsRef.current.ignoreError) {
                        _context.next = 18;
                        break;
                      }

                      return _context.abrupt("return");

                    case 18:
                      _context.t1 = !state.unmounted;

                      if (!_context.t1) {
                        _context.next = 23;
                        break;
                      }

                      _context.next = 22;
                      return _regeneratorRuntime.awrap(optionsRef.current.condition(res, _error));

                    case 22:
                      _context.t1 = _context.sent;

                    case 23:
                      if (!_context.t1) {
                        _context.next = 25;
                        break;
                      }

                      setTimeout(poll);

                    case 25:
                      _context.prev = 25;
                      !state.unmounted && setPolling(false);
                      return _context.finish(25);

                    case 28:
                    case "end":
                      return _context.stop();
                  }
                }
              }, null, null, [[2,, 25, 28], [4, 10]]);
            }, immediate ? 0 : optionsRef.current.duration || 5000);

          case 4:
          case "end":
            return _context2.stop();
        }
      }
    });
  }, []);
  useOnUpdate(function _callee3() {
    return _regeneratorRuntime.async(function _callee3$(_context3) {
      while (1) {
        switch (_context3.prev = _context3.next) {
          case 0:
            if (!pollingRef.current) {
              _context3.next = 2;
              break;
            }

            return _context3.abrupt("return");

          case 2:
            _context3.next = 4;
            return _regeneratorRuntime.awrap(optionsRef.current.condition());

          case 4:
            if (!_context3.sent) {
              _context3.next = 6;
              break;
            }

            poll(options.immediately);

          case 6:
          case "end":
            return _context3.stop();
        }
      }
    });
  }, options.args || [], false);
  useOnUnmount(function () {
    window.clearTimeout(state.timer);
    state.unmounted = true;
  });
  return {
    polling: polling,
    error: error
  };
}