@rpldy/chunked-sender/lib/cjs/chunkedSender/sendChunks.js

adds chunked upload capabilities on top of the regular XHR uploads

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.handleChunk = exports.default = void 0;
var _shared = require("@rpldy/shared");
var _ChunkedSendError = _interopRequireDefault(require("./ChunkedSendError"));
var _handleChunkRequest = _interopRequireDefault(require("./handleChunkRequest"));
var _getChunksToSend = _interopRequireDefault(require("./getChunksToSend"));
var _sendChunk = _interopRequireDefault(require("./sendChunk"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
const resolveOnError = (chunkedState, resolve, ex) => {
  if (ex instanceof _ChunkedSendError.default) {
    const chunkError = chunkedState.getState().lastChunkErrorData;
    resolve({
      state: _shared.FILE_STATES.ERROR,
      response: {
        reason: "At least one chunk failed",
        chunkUploadResponse: chunkError
      }
    });
  } else {
    resolve({
      state: _shared.FILE_STATES.ERROR,
      response: ex.message
    });
  }
};
const finalizeOnFinish = (chunkedState, item, resolve, status) => {
  chunkedState.updateState(state => {
    state.finished = true;
  });
  resolve({
    state: status,
    response: {
      results: chunkedState.getState().responses
    }
  });
};
const resolveOnAllChunksFinished = (chunkedState, item, resolve) => {
  const state = chunkedState.getState();
  const finished = !state.chunks.length;
  if (state.aborted) {
    _shared.logger.debugLog(`chunkedSender: chunked upload aborted for item: ${item.id}`);
    finalizeOnFinish(chunkedState, item, resolve, _shared.FILE_STATES.ABORTED);
  } else if (finished && !state.error) {
    _shared.logger.debugLog(`chunkedSender: chunked upload finished for item: ${item.id}`, state.responses);
    finalizeOnFinish(chunkedState, item, resolve, _shared.FILE_STATES.FINISHED);
  }
  return finished || state.error;
};
const handleChunk = (chunkedState, item, onProgress, chunkResolve, chunk, trigger) => new Promise((resolve, reject) => {
  try {
    const chunkSendResult = (0, _sendChunk.default)(chunk, chunkedState, item, onProgress, trigger);
    (0, _handleChunkRequest.default)(chunkedState, item, chunk.id, chunkSendResult, trigger, onProgress).then(() => {
      resolve();
      if (!resolveOnAllChunksFinished(chunkedState, item, chunkResolve)) {
        sendChunks(chunkedState, item, onProgress, chunkResolve, trigger);
      }
    });
  } catch (ex) {
    reject(ex);
  }
});
exports.handleChunk = handleChunk;
const sendChunks = (chunkedState, item, onProgress, resolve, trigger) => {
  const state = chunkedState.getState();
  if (!state.finished && !state.aborted) {
    const inProgress = Object.keys(state.requests).length;
    if (!inProgress || state.parallel && state.parallel > inProgress) {
      let chunks;
      try {
        chunks = (0, _getChunksToSend.default)(chunkedState);
      } catch (ex) {
        resolveOnError(chunkedState, resolve, ex);
      }
      if (chunks) {
        _shared.logger.debugLog(`chunkedSender: about to send ${chunks.length} chunks for item: ${item.id} with parallel: ${state.parallel}`);
        chunks.forEach(chunk => {
          handleChunk(chunkedState, item, onProgress, resolve, chunk, trigger).catch(ex => {
            chunkedState.updateState(state => {
              state.error = true;
            });
            resolveOnError(chunkedState, resolve, ex);
          });
        });
      }
    }
  }
};
var _default = exports.default = sendChunks;