@rpldy/uploader/lib/cjs/queue/processBatchItems.js

the processing and queuing engine for react-uploady

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _shared = require("@rpldy/shared");
var _consts = require("../consts");
var _processFinishedRequest = _interopRequireDefault(require("./processFinishedRequest"));
var _preSendPrepare = require("./preSendPrepare");
var _itemHelpers = require("./itemHelpers");
var _batchHelpers = require("./batchHelpers");
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const preparePreRequestItems = (0, _preSendPrepare.getItemsPrepareUpdater)(_consts.UPLOADER_EVENTS.REQUEST_PRE_SEND, items => items, (items, options) => ({
  items,
  options
}));
const updateUploadingState = (queue, items, sendResult) => {
  queue.updateState(state => {
    items.forEach(bi => {
      const item = state.items[bi.id];
      item.state = _shared.FILE_STATES.UPLOADING;
      state.aborts[bi.id] = sendResult.abort;
    });
  });
};
const sendAllowedItems = (queue, itemsSendData, next) => {
  const {
    items,
    options
  } = itemsSendData;
  const batch = queue.getState().batches[items[0].batchId]?.batch;
  if (batch) {
    let sendResult;
    try {
      sendResult = queue.sender.send(items, batch, options);
    } catch (ex) {
      _shared.logger.debugLog(`uploader.queue: sender failed with unexpected error`, ex);
      sendResult = {
        request: Promise.resolve({
          status: 0,
          state: _shared.FILE_STATES.ERROR,
          response: ex.message
        }),
        abort: () => false,
        senderType: "exception-handler"
      };
    }
    const {
      request
    } = sendResult;
    updateUploadingState(queue, items, sendResult);
    request.then(requestInfo => {
      const finishedData = items.map(item => ({
        id: item.id,
        info: requestInfo
      }));
      (0, _processFinishedRequest.default)(queue, finishedData, next);
    });
  }
};
const reportCancelledItems = (queue, items, cancelledResults, next) => {
  const cancelledItemsIds = cancelledResults.map((isCancelled, index) => isCancelled ? items[index].id : null).filter(Boolean);
  if (cancelledItemsIds.length) {
    const finishedData = cancelledItemsIds.map(id => ({
      id,
      info: {
        status: 0,
        state: _shared.FILE_STATES.CANCELLED,
        response: "cancel"
      }
    }));
    (0, _processFinishedRequest.default)(queue, finishedData, next);
  }
  return !!cancelledItemsIds.length;
};
const reportPreparedError = (error, queue, items, next) => {
  const finishedData = items.map(({
    id
  }) => ({
    id,
    info: {
      status: 0,
      state: _shared.FILE_STATES.ERROR,
      response: error
    }
  }));
  (0, _processFinishedRequest.default)(queue, finishedData, next);
};
const getAllowedItem = (id, queue) => {
  const item = queue.getState().items[id];
  return item && !(0, _itemHelpers.getIsItemFinalized)(item) ? item : undefined;
};
const processAllowedItems = ({
  allowedItems,
  cancelledResults,
  queue,
  items,
  ids,
  next
}) => {
  const afterPreparePromise = allowedItems.length ? preparePreRequestItems(queue, allowedItems) : Promise.resolve();
  let finalCancelledResults = cancelledResults;
  return afterPreparePromise.catch(err => {
    _shared.logger.debugLog("uploader.queue: encountered error while preparing items for request", err);
    reportPreparedError(err, queue, items, next);
  }).then(itemsSendData => {
    let nextP;
    if (itemsSendData) {
      if (itemsSendData.cancelled) {
        finalCancelledResults = ids.map(() => true);
      } else {
        const hasAborted = itemsSendData.items.some(item => (0, _itemHelpers.getIsItemFinalized)(item));
        if (!hasAborted) {
          sendAllowedItems(queue, {
            items: itemsSendData.items,
            options: itemsSendData.options
          }, next);
        } else {
          _shared.logger.debugLog("uploader.queue: send data contains aborted items - not sending");
        }
      }
    }
    if (!reportCancelledItems(queue, items, finalCancelledResults, next)) {
      nextP = next(queue);
    }
    return nextP;
  });
};
const processBatchItems = (queue, ids, next) => {
  const state = queue.getState();
  let items = Object.values(state.items);
  items = items.filter(item => ids.includes(item.id) && !(0, _itemHelpers.getIsItemFinalized)(item));
  return Promise.all(items.map(i => {
    const {
      batchOptions
    } = (0, _batchHelpers.getBatchDataFromItemId)(queue, i.id);
    return queue.runCancellable(_consts.UPLOADER_EVENTS.ITEM_START, i, batchOptions);
  })).then(cancelledResults => {
    let allowedItems = cancelledResults.map((isCancelled, index) => isCancelled ? null : getAllowedItem(items[index].id, queue)).filter(Boolean);
    return {
      allowedItems,
      cancelledResults,
      queue,
      items,
      ids,
      next
    };
  }).then(processAllowedItems);
};
var _default = exports.default = processBatchItems;