@rpldy/uploader/lib/esm/uploader.js

the processing and queuing engine for react-uploady

import addLife, { createLifePack } from "@rpldy/life-events";
import { invariant, logger, triggerCancellable, devFreeze, merge, clone } from "@rpldy/shared";
import getAbortEnhancer from "@rpldy/abort";
import getProcessor from "./processor";
import { UPLOADER_EVENTS } from "./consts";
import { getMandatoryOptions, deepProxyUnwrap } from "./utils";
import composeEnhancers from "./composeEnhancers";
const EVENT_NAMES = Object.values(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 => composeEnhancers(getAbortEnhancer(), extEnhancer);
const getEnhancedUploader = (uploader, options, triggerWithUnwrap, setEnhancerTime) => {
  const enhancer = options.enhancer ? getComposedEnhancer(options.enhancer) : getAbortEnhancer();
  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 = {};
  logger.debugLog(`uploady.uploader: creating new instance (${uploaderId})`, {
    options,
    counter
  });
  let uploaderOptions = getMandatoryOptions(options);
  const clearPending = () => {
    processor.clearPendingBatches();
  };
  const getOptions = () => {
    return clone(uploaderOptions);
  };
  let {
    trigger,
    target: uploader
  } = addLife({
    id: uploaderId,
    update: updateOptions => {
      uploaderOptions = merge({}, uploaderOptions, updateOptions);
      return uploader;
    },
    add: (files, addOptions) => {
      const processOptions = merge({}, uploaderOptions, addOptions);
      if (processOptions.clearPendingOnAdd) {
        clearPending();
      }
      return processor.addNewBatch(files, processOptions).then(() => {
        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) => {
      invariant(enhancerTime, EXT_OUTSIDE_ENHANCER_TIME);
      invariant(!extensions[name], EXT_ALREADY_EXISTS, name);
      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 = createLifePack(() => data.map(deepProxyUnwrap));
    return trigger(name, lp);
  };
  const cancellable = triggerCancellable(triggerWithUnwrap);
  const enhancedUploader = getEnhancedUploader(uploader, uploaderOptions, triggerWithUnwrap, state => {
    enhancerTime = state;
  });
  const processor = getProcessor(triggerWithUnwrap, cancellable, uploaderOptions, enhancedUploader.id);
  return devFreeze(enhancedUploader);
};
export default createUploader;