Function DMOpsQueueHandler

lib/shared/dm-ops/dm-ops-queue-handler.react.js:41–308

()

    };

function DMOpsQueueHandler(): React.Node {
  const dispatch = useDispatch();

  const prune = React.useCallback(() => {
    const now = Date.now();
    dispatch({
      type: pruneDMOpsQueueActionType,
      payload: {
        pruneMaxTimestamp: now - QUEUED_OPERATION_TTL,
      },
    });
  }, [dispatch]);

  React.useEffect(() => {
    const timeoutID = setTimeout(prune, FIRST_PRUNING_DELAY);
    const intervalID = setInterval(prune, PRUNING_FREQUENCY);

    return () => {
      clearTimeout(timeoutID);
      clearInterval(intervalID);
    };
  }, [prune]);

  const threadInfos = useSelector(threadInfoSelector);

  const queuedThreadOperations = useSelector(
    state => state.queuedDMOperations.threadQueue,
  );

  const processDMOperation = useProcessDMOperation();

  const processItem = React.useCallback(
    async (item: QueueItem) => {
      if (item.type === 'operation') {
        await processDMOperation({
          // This is `INBOUND` because we assume that when generating
          // `dmOperationSpecificationTypes.OUBOUND` it should be possible
          // to be processed and never queued up.
          type: dmOperationSpecificationTypes.INBOUND,
          op: item.operation,
          // There is no metadata, because messages were confirmed when
          // adding to the queue.
          metadata: null,
        });
      } else if (item.type === 'action') {
        dispatch(item.action);
      } else {
        item.itemFunction();
      }
    },
    [dispatch, processDMOperation],
  );

  const { enqueue } = useActionsQueue(processItem);

  const runningThreadOperations = React.useRef<Set<string>>(new Set());

  React.useEffect(() => {