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

the processing and queuing engine for react-uploady

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.default = void 0;
var _lifeEvents = _interopRequireWildcard(require("@rpldy/life-events"));
var _shared = require("@rpldy/shared");
var _abort = _interopRequireDefault(require("@rpldy/abort"));
var _processor = _interopRequireDefault(require("./processor"));
var _consts = require("./consts");
var _utils = require("./utils");
var _composeEnhancers = _interopRequireDefault(require("./composeEnhancers"));
function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
const EVENT_NAMES = Object.values(_consts.UPLOADER_EVENTS);
const EXT_OUTSIDE_ENHANCER_TIME = "Uploady - uploader extensions can only be registered by enhancers",
  EXT_ALREADY_EXISTS = "Uploady - uploader extension by this name [%s] already exists";
let counter = 0;
const getComposedEnhancer = extEnhancer => (0, _composeEnhancers.default)((0, _abort.default)(), extEnhancer);
const getEnhancedUploader = (uploader, options, triggerWithUnwrap, setEnhancerTime) => {
  const enhancer = options.enhancer ? getComposedEnhancer(options.enhancer) : (0, _abort.default)();
  setEnhancerTime(true);
  const enhanced = enhancer(uploader, triggerWithUnwrap);
  setEnhancerTime(false);
  return enhanced || uploader;
};
const createUploader = options => {
  counter += 1;
  const uploaderId = `uploader-${counter}`;
  let enhancerTime = false;
  const extensions = {};
  _shared.logger.debugLog(`uploady.uploader: creating new instance (${uploaderId})`, {
    options,
    counter
  });
  let uploaderOptions = (0, _utils.getMandatoryOptions)(options);
  const clearPending = () => {
    processor.clearPendingBatches();
  };
  const getOptions = () => {
    return (0, _shared.clone)(uploaderOptions);
  };
  let {
    trigger,
    target: uploader
  } = (0, _lifeEvents.default)({
    id: uploaderId,
    update: updateOptions => {
      uploaderOptions = (0, _shared.merge)({}, uploaderOptions, updateOptions);
      return uploader;
    },
    add: (files, addOptions) => {
      const processOptions = (0, _shared.merge)({}, uploaderOptions, addOptions);
      if (processOptions.clearPendingOnAdd) {
        clearPending();
      }
      return processor.addNewBatch(files, processOptions).then(() => {
        _shared.logger.debugLog(`uploady.uploader: finished adding file data to be processed`);
      });
    },
    upload: uploadOptions => {
      processor.processPendingBatches(uploadOptions);
    },
    abort: id => {
      processor.abort(id);
    },
    abortBatch: id => {
      processor.abortBatch(id);
    },
    getOptions,
    clearPending,
    registerExtension: (name, methods) => {
      (0, _shared.invariant)(enhancerTime, EXT_OUTSIDE_ENHANCER_TIME);
      (0, _shared.invariant)(!extensions[name], EXT_ALREADY_EXISTS, name);
      _shared.logger.debugLog(`uploady.uploader: registering extension: ${name.toString()}`, methods);
      extensions[name] = methods;
    },
    getExtension: name => {
      return extensions[name];
    }
  }, EVENT_NAMES, {
    canAddEvents: false,
    canRemoveEvents: false
  });
  const triggerWithUnwrap = (name, ...data) => {
    const lp = (0, _lifeEvents.createLifePack)(() => data.map(_utils.deepProxyUnwrap));
    return trigger(name, lp);
  };
  const cancellable = (0, _shared.triggerCancellable)(triggerWithUnwrap);
  const enhancedUploader = getEnhancedUploader(uploader, uploaderOptions, triggerWithUnwrap, state => {
    enhancerTime = state;
  });
  const processor = (0, _processor.default)(triggerWithUnwrap, cancellable, uploaderOptions, enhancedUploader.id);
  return (0, _shared.devFreeze)(enhancedUploader);
};
var _default = exports.default = createUploader;