use-tus 0.5.0 → 0.7.0

package/dist/index.cjs.js

@@ -3,29 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var react = require('react');
-var tus = require('tus-js-client');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () {
-            return e[k];
-          }
-        });
-      }
-    });
-  }
-  n['default'] = e;
-  return Object.freeze(n);
-}
-
-var tus__namespace = /*#__PURE__*/_interopNamespace(tus);
+var tusJsClient = require('tus-js-client');
 
 function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
   try {
@@ -63,28 +41,6 @@ function _asyncToGenerator(fn) {
   };
 }
 
-function _classCallCheck(instance, Constructor) {
-  if (!(instance instanceof Constructor)) {
-    throw new TypeError("Cannot call a class as a function");
-  }
-}
-
-function _defineProperties(target, props) {
-  for (var i = 0; i < props.length; i++) {
-    var descriptor = props[i];
-    descriptor.enumerable = descriptor.enumerable || false;
-    descriptor.configurable = true;
-    if ("value" in descriptor) descriptor.writable = true;
-    Object.defineProperty(target, descriptor.key, descriptor);
-  }
-}
-
-function _createClass(Constructor, protoProps, staticProps) {
-  if (protoProps) _defineProperties(Constructor.prototype, protoProps);
-  if (staticProps) _defineProperties(Constructor, staticProps);
-  return Constructor;
-}
-
 function _defineProperty(obj, key, value) {
   if (key in obj) {
     Object.defineProperty(obj, key, {
@@ -190,9 +146,204 @@ function _nonIterableRest() {
   throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
 }
 
+var createUpload = function createUpload(file, options, dispatchIsAborted) {
+  var upload = new tusJsClient.Upload(file, options);
+  var originalStart = upload.start.bind(upload);
+  var originalAbort = upload.abort.bind(upload);
+
+  var start = function start() {
+    originalStart();
+    dispatchIsAborted(false);
+  };
+
+  var abort = function () {
+    var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+      return regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              originalAbort();
+              dispatchIsAborted(true);
+
+            case 2:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, _callee);
+    }));
+
+    return function abort() {
+      return _ref.apply(this, arguments);
+    };
+  }();
+
+  upload.start = start;
+  upload.abort = abort;
+  return {
+    upload: upload,
+    originalStart: originalStart,
+    originalAbort: originalAbort
+  };
+};
+
+var startOrResumeUpload = function startOrResumeUpload(upload) {
+  upload.findPreviousUploads().then(function (previousUploads) {
+    if (previousUploads.length) {
+      upload.resumeFromPreviousUpload(previousUploads[0]);
+    }
+
+    upload.start();
+  });
+};
+
+var useAutoAbort = function useAutoAbort(upload, abort, autoAbort) {
+  react.useEffect(function () {
+    var abortUploading = function () {
+      var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
+        return regeneratorRuntime.wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                if (!(!upload || !abort)) {
+                  _context.next = 2;
+                  break;
+                }
+
+                return _context.abrupt("return");
+
+              case 2:
+                _context.next = 4;
+                return abort();
+
+              case 4:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee);
+      }));
+
+      return function abortUploading() {
+        return _ref.apply(this, arguments);
+      };
+    }();
+
+    return function () {
+      if (!autoAbort) {
+        return;
+      }
+
+      abortUploading();
+    };
+  }, [autoAbort, upload]);
+};
+
+var defaultUseTusOptionsValue = Object.freeze({
+  autoAbort: true,
+  autoStart: false
+});
+var useMergeTusOptions = function useMergeTusOptions(options) {
+  return react.useMemo(function () {
+    return _objectSpread2(_objectSpread2({}, defaultUseTusOptionsValue), options || {});
+  }, [options]);
+};
+
+var initialUseTusState = Object.freeze({
+  upload: undefined,
+  isSuccess: false,
+  isAborted: false,
+  error: undefined,
+  originalAbort: undefined
+});
+var useTus = function useTus(baseOption) {
+  var _useMergeTusOptions = useMergeTusOptions(baseOption),
+      autoAbort = _useMergeTusOptions.autoAbort,
+      autoStart = _useMergeTusOptions.autoStart,
+      uploadOptions = _useMergeTusOptions.uploadOptions;
+
+  var _useState = react.useState(initialUseTusState),
+      _useState2 = _slicedToArray(_useState, 2),
+      tusState = _useState2[0],
+      setTusState = _useState2[1];
+
+  var updateTusState = react.useCallback(function (newOptions) {
+    setTusState(function (tus) {
+      return _objectSpread2(_objectSpread2({}, tus), newOptions);
+    });
+  }, []);
+  var setUpload = react.useCallback(function (file) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+
+    var targetOptions = _objectSpread2(_objectSpread2({}, uploadOptions), options);
+
+    var onSuccess = function onSuccess() {
+      var _targetOptions$onSucc;
+
+      updateTusState({
+        isSuccess: true
+      });
+      targetOptions === null || targetOptions === void 0 ? void 0 : (_targetOptions$onSucc = targetOptions.onSuccess) === null || _targetOptions$onSucc === void 0 ? void 0 : _targetOptions$onSucc.call(targetOptions);
+    };
+
+    var onError = function onError(error) {
+      var _targetOptions$onErro;
+
+      updateTusState({
+        error: error
+      });
+      targetOptions === null || targetOptions === void 0 ? void 0 : (_targetOptions$onErro = targetOptions.onError) === null || _targetOptions$onErro === void 0 ? void 0 : _targetOptions$onErro.call(targetOptions, error);
+    };
+
+    var mergedUploadOptions = _objectSpread2(_objectSpread2({}, targetOptions), {}, {
+      onSuccess: onSuccess,
+      onError: onError
+    });
+
+    var dispatchIsAborted = function dispatchIsAborted(isAborted) {
+      updateTusState({
+        isAborted: isAborted
+      });
+    };
+
+    var _createUpload = createUpload(file, mergedUploadOptions, dispatchIsAborted),
+        upload = _createUpload.upload,
+        originalAbort = _createUpload.originalAbort;
+
+    if (autoStart) {
+      startOrResumeUpload(upload);
+    }
+
+    updateTusState(_objectSpread2(_objectSpread2({}, initialUseTusState), {}, {
+      upload: upload,
+      originalAbort: originalAbort
+    }));
+  }, [autoStart, updateTusState, uploadOptions]);
+  var remove = react.useCallback(function () {
+    var _tusState$originalAbo;
+
+    tusState === null || tusState === void 0 ? void 0 : (_tusState$originalAbo = tusState.originalAbort) === null || _tusState$originalAbo === void 0 ? void 0 : _tusState$originalAbo.call(tusState);
+    setTusState(initialUseTusState);
+  }, [tusState]);
+  var tusResult = react.useMemo(function () {
+    var _tusState$isSuccess, _tusState$isAborted;
+
+    return {
+      upload: tusState === null || tusState === void 0 ? void 0 : tusState.upload,
+      isSuccess: (_tusState$isSuccess = tusState === null || tusState === void 0 ? void 0 : tusState.isSuccess) !== null && _tusState$isSuccess !== void 0 ? _tusState$isSuccess : false,
+      error: tusState === null || tusState === void 0 ? void 0 : tusState.error,
+      isAborted: (_tusState$isAborted = tusState === null || tusState === void 0 ? void 0 : tusState.isAborted) !== null && _tusState$isAborted !== void 0 ? _tusState$isAborted : false,
+      setUpload: setUpload,
+      remove: remove
+    };
+  }, [tusState, setUpload, remove]);
+  useAutoAbort(tusResult.upload, tusState.originalAbort, autoAbort !== null && autoAbort !== void 0 ? autoAbort : false);
+  return tusResult;
+};
+
 var ERROR_MESSAGES = {
-  tusClientHasNotFounded: 'No TusClient set, use TusClientProvider to set one',
-  tusIsNotSupported: 'This browser does not support uploads. Please use a modern browser instead.'
+  tusClientHasNotFounded: "No TusClient set, use TusClientProvider to set one",
+  tusIsNotSupported: "This browser does not support uploads. Please use a modern browser instead."
 };
 
 var TusClientStateContext = react.createContext(undefined);
@@ -200,7 +351,7 @@ var TusClientDispatchContext = react.createContext(undefined);
 var useTusClientState = function useTusClientState() {
   var tusClientState = react.useContext(TusClientStateContext);
 
-  if (!tusClientState && process.env.NODE_ENV !== 'production') {
+  if (!tusClientState && process.env.NODE_ENV !== "production") {
     throw new Error(ERROR_MESSAGES.tusClientHasNotFounded);
   }
 
@@ -211,7 +362,7 @@ var useTusClientState = function useTusClientState() {
 var useTusClientDispatch = function useTusClientDispatch() {
   var tusClientDispatch = react.useContext(TusClientDispatchContext);
 
-  if (!tusClientDispatch && process.env.NODE_ENV !== 'production') {
+  if (!tusClientDispatch && process.env.NODE_ENV !== "production") {
     throw new Error(ERROR_MESSAGES.tusClientHasNotFounded);
   }
 
@@ -222,7 +373,7 @@ var useTusClientDispatch = function useTusClientDispatch() {
 
 var insertUploadInstance = function insertUploadInstance(cacheKey, upload) {
   return {
-    type: 'INSERT_UPLOAD_INSTANCE',
+    type: "INSERT_UPLOAD_INSTANCE",
     payload: {
       cacheKey: cacheKey,
       uploadState: {
@@ -235,7 +386,7 @@ var insertUploadInstance = function insertUploadInstance(cacheKey, upload) {
 };
 var updateSuccessUpload = function updateSuccessUpload(cacheKey) {
   return {
-    type: 'UPDATE_SUCCESS_UPLOAD',
+    type: "UPDATE_SUCCESS_UPLOAD",
     payload: {
       cacheKey: cacheKey
     }
@@ -243,7 +394,7 @@ var updateSuccessUpload = function updateSuccessUpload(cacheKey) {
 };
 var updateErrorUpload = function updateErrorUpload(cacheKey, error) {
   return {
-    type: 'UPDATE_ERROR_UPLOAD',
+    type: "UPDATE_ERROR_UPLOAD",
     payload: {
       cacheKey: cacheKey,
       error: error
@@ -252,7 +403,7 @@ var updateErrorUpload = function updateErrorUpload(cacheKey, error) {
 };
 var updateIsAbortedUpload = function updateIsAbortedUpload(cacheKey, isAborted) {
   return {
-    type: 'UPDATE_IS_ABORTED_UPLOAD',
+    type: "UPDATE_IS_ABORTED_UPLOAD",
     payload: {
       cacheKey: cacheKey,
       isAborted: isAborted
@@ -261,202 +412,78 @@ var updateIsAbortedUpload = function updateIsAbortedUpload(cacheKey, isAborted)
 };
 var removeUploadInstance = function removeUploadInstance(cacheKey) {
   return {
-    type: 'REMOVE_UPLOAD_INSTANCE',
+    type: "REMOVE_UPLOAD_INSTANCE",
     payload: {
       cacheKey: cacheKey
     }
   };
 };
-var updateTusHandlerOptions = function updateTusHandlerOptions(payload) {
+var updateDefaultOptions = function updateDefaultOptions(defaultOptions) {
   return {
-    type: 'UPDATE_TUS_HANDLER_OPTIONS',
-    payload: payload
-  };
-};
-
-var createOptionHandler = function createOptionHandler(handlers, _ref) {
-  var dispatch = _ref.dispatch,
-      internalDispatch = _ref.internalDispatch,
-      cacheKey = _ref.cacheKey;
-
-  var onSuccess = function onSuccess() {
-    if (cacheKey) {
-      dispatch(updateSuccessUpload(cacheKey));
-    }
-
-    if (!cacheKey) {
-      internalDispatch(function (internalTusState) {
-        return _objectSpread2(_objectSpread2({}, internalTusState), {}, {
-          isSuccess: true
-        });
-      });
-    }
-
-    if (handlers.onSuccess) {
-      handlers.onSuccess();
-    }
-  };
-
-  var onError = function onError(err) {
-    if (cacheKey) {
-      dispatch(updateErrorUpload(cacheKey, err));
-    }
-
-    if (!cacheKey) {
-      internalDispatch(function (internalTusState) {
-        return _objectSpread2(_objectSpread2({}, internalTusState), {}, {
-          error: err
-        });
-      });
-    }
-
-    if (handlers.onError) {
-      handlers.onError(err);
+    type: "UPDATE_DEFAULT_OPTIONS",
+    payload: {
+      defaultOptions: defaultOptions
     }
   };
-
-  return {
-    onSuccess: onSuccess,
-    onError: onError
-  };
 };
-var startOrResumeUpload = function startOrResumeUpload(upload) {
-  upload.findPreviousUploads().then(function (previousUploads) {
-    if (previousUploads.length) {
-      upload.resumeFromPreviousUpload(previousUploads[0]);
-    }
 
-    upload.start();
-  });
-};
-var createUpload = function createUpload(file, options, _ref2) {
-  var dispatch = _ref2.dispatch,
-      internalDispatch = _ref2.internalDispatch,
-      cacheKey = _ref2.cacheKey;
-  var upload = new tus.Upload(file, options);
-  var originalStart = upload.start.bind(upload);
-  var originalAbort = upload.abort.bind(upload);
+var useTusStore = function useTusStore(cacheKey, baseOption) {
+  var _tusResult$upload;
 
-  var dispatchIsAborted = function dispatchIsAborted(isAborted) {
-    if (cacheKey) {
-      dispatch(updateIsAbortedUpload(cacheKey, isAborted));
-      return;
-    }
+  var _useMergeTusOptions = useMergeTusOptions(baseOption),
+      autoAbort = _useMergeTusOptions.autoAbort,
+      autoStart = _useMergeTusOptions.autoStart,
+      uploadOptions = _useMergeTusOptions.uploadOptions;
 
-    internalDispatch(function (internalTusState) {
-      return _objectSpread2(_objectSpread2({}, internalTusState), {}, {
-        isAborted: isAborted
-      });
-    });
-  };
+  var _useTusClientState = useTusClientState(),
+      defaultOptions = _useTusClientState.defaultOptions,
+      uploads = _useTusClientState.uploads;
 
-  var start = function start() {
-    originalStart();
-    dispatchIsAborted(false);
-  };
+  var tusClientDispatch = useTusClientDispatch();
+  var setUpload = react.useCallback(function (file) {
+    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
 
-  var abort = function () {
-    var _ref3 = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
-      return regeneratorRuntime.wrap(function _callee$(_context) {
-        while (1) {
-          switch (_context.prev = _context.next) {
-            case 0:
-              originalAbort();
-              dispatchIsAborted(true);
+    var targetOptions = _objectSpread2(_objectSpread2(_objectSpread2({}, defaultOptions === null || defaultOptions === void 0 ? void 0 : defaultOptions(file)), uploadOptions), options);
 
-            case 2:
-            case "end":
-              return _context.stop();
-          }
-        }
-      }, _callee);
-    }));
+    var onSuccess = function onSuccess() {
+      var _targetOptions$onSucc;
 
-    return function abort() {
-      return _ref3.apply(this, arguments);
+      tusClientDispatch(updateSuccessUpload(cacheKey));
+      targetOptions === null || targetOptions === void 0 ? void 0 : (_targetOptions$onSucc = targetOptions.onSuccess) === null || _targetOptions$onSucc === void 0 ? void 0 : _targetOptions$onSucc.call(targetOptions);
     };
-  }();
-
-  upload.start = start;
-  upload.abort = abort;
-  return upload;
-};
-
-var defaultUseTusOptionsValue = Object.freeze({
-  cacheKey: undefined,
-  autoAbort: true,
-  autoStart: false
-});
-var initialUseTusState = Object.freeze({
-  upload: undefined,
-  isSuccess: false,
-  isAborted: false,
-  error: undefined
-});
-var useTus = function useTus(useTusOptions) {
-  var _defaultUseTusOptions = _objectSpread2(_objectSpread2({}, defaultUseTusOptionsValue), useTusOptions || {}),
-      cacheKey = _defaultUseTusOptions.cacheKey,
-      autoAbort = _defaultUseTusOptions.autoAbort,
-      autoStart = _defaultUseTusOptions.autoStart;
 
-  var _useState = react.useState(initialUseTusState),
-      _useState2 = _slicedToArray(_useState, 2),
-      internalTusState = _useState2[0],
-      setInternalTusState = _useState2[1];
+    var onError = function onError(error) {
+      var _targetOptions$onErro;
 
-  var tusClientState = useTusClientState();
-  var tusClientDispatch = useTusClientDispatch();
-  var tus = tusClientState.tusHandler.getTus;
-  var setUpload = react.useCallback(function (file) {
-    var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    var dispatcher = {
-      cacheKey: cacheKey,
-      dispatch: tusClientDispatch,
-      internalDispatch: setInternalTusState
+      tusClientDispatch(updateErrorUpload(cacheKey, error));
+      targetOptions === null || targetOptions === void 0 ? void 0 : (_targetOptions$onErro = targetOptions.onError) === null || _targetOptions$onErro === void 0 ? void 0 : _targetOptions$onErro.call(targetOptions, error);
     };
 
-    var targetOptions = _objectSpread2(_objectSpread2({}, tus.defaultOptions(file)), options);
-
-    var _createOptionHandler = createOptionHandler({
-      onError: targetOptions.onError,
-      onSuccess: targetOptions.onSuccess
-    }, dispatcher),
-        onSuccess = _createOptionHandler.onSuccess,
-        onError = _createOptionHandler.onError;
-
-    var uploadOptions = _objectSpread2(_objectSpread2({}, targetOptions), {}, {
+    var mergedUploadOptions = _objectSpread2(_objectSpread2({}, targetOptions), {}, {
       onSuccess: onSuccess,
       onError: onError
     });
 
-    var upload = createUpload(file, uploadOptions, dispatcher);
+    var dispatchIsAborted = function dispatchIsAborted(isAborted) {
+      tusClientDispatch(updateIsAbortedUpload(cacheKey, isAborted));
+    };
+
+    var _createUpload = createUpload(file, mergedUploadOptions, dispatchIsAborted),
+        upload = _createUpload.upload;
 
     if (autoStart) {
       startOrResumeUpload(upload);
     }
 
-    if (cacheKey) {
-      tusClientDispatch(insertUploadInstance(cacheKey, upload));
-      return;
-    }
-
-    setInternalTusState(_objectSpread2(_objectSpread2({}, initialUseTusState), {}, {
-      upload: upload
-    }));
-  }, [tusClientDispatch, cacheKey, tus, autoStart]);
+    tusClientDispatch(insertUploadInstance(cacheKey, upload));
+  }, [autoStart, cacheKey, defaultOptions, tusClientDispatch, uploadOptions]);
   var targetTusState = react.useMemo(function () {
-    return cacheKey ? tusClientState.uploads[cacheKey] : internalTusState;
-  }, [cacheKey, tusClientState, internalTusState]);
+    return uploads[cacheKey];
+  }, [cacheKey, uploads]);
   var remove = react.useCallback(function () {
     var _targetTusState$uploa;
 
     targetTusState === null || targetTusState === void 0 ? void 0 : (_targetTusState$uploa = targetTusState.upload) === null || _targetTusState$uploa === void 0 ? void 0 : _targetTusState$uploa.abort();
-
-    if (!cacheKey) {
-      setInternalTusState(initialUseTusState);
-      return;
-    }
-
     tusClientDispatch(removeUploadInstance(cacheKey));
   }, [targetTusState, tusClientDispatch, cacheKey]);
   var tusResult = react.useMemo(function () {
@@ -471,80 +498,13 @@ var useTus = function useTus(useTusOptions) {
       remove: remove
     };
   }, [targetTusState, setUpload, remove]);
-  react.useEffect(function () {
-    var abortUploading = function () {
-      var _ref = _asyncToGenerator(regeneratorRuntime.mark(function _callee() {
-        return regeneratorRuntime.wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (tusResult.upload) {
-                  _context.next = 2;
-                  break;
-                }
-
-                return _context.abrupt("return");
-
-              case 2:
-                _context.next = 4;
-                return tusResult.upload.abort();
-
-              case 4:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }));
-
-      return function abortUploading() {
-        return _ref.apply(this, arguments);
-      };
-    }();
-
-    return function () {
-      if (!autoAbort) {
-        return;
-      }
-
-      abortUploading();
-    };
-  }, [autoAbort, tusResult.upload]);
+  useAutoAbort(tusResult.upload, (_tusResult$upload = tusResult.upload) === null || _tusResult$upload === void 0 ? void 0 : _tusResult$upload.abort, autoAbort !== null && autoAbort !== void 0 ? autoAbort : false);
   return tusResult;
 };
 
-var initialDefaultOptions = function initialDefaultOptions() {
-  return tus__namespace.defaultOptions;
-};
-var TusHandler = function () {
-  function TusHandler(tusConfigs) {
-    _classCallCheck(this, TusHandler);
-
-    var _ref = tusConfigs || {},
-        _ref$canStoreURLs = _ref.canStoreURLs,
-        canStoreURLs = _ref$canStoreURLs === void 0 ? tus__namespace.canStoreURLs : _ref$canStoreURLs,
-        _ref$defaultOptions = _ref.defaultOptions,
-        defaultOptions = _ref$defaultOptions === void 0 ? initialDefaultOptions : _ref$defaultOptions;
-
-    this.tus = _objectSpread2(_objectSpread2({}, tus__namespace), {}, {
-      canStoreURLs: canStoreURLs,
-      defaultOptions: defaultOptions
-    });
-  }
-
-  _createClass(TusHandler, [{
-    key: "getTus",
-    get: function get() {
-      return this.tus;
-    }
-  }]);
-
-  return TusHandler;
-}();
-
 var tusClientReducer = function tusClientReducer(state, actions) {
   switch (actions.type) {
-    case 'INSERT_UPLOAD_INSTANCE':
+    case "INSERT_UPLOAD_INSTANCE":
       {
         var _actions$payload = actions.payload,
             _cacheKey = _actions$payload.cacheKey,
@@ -554,7 +514,7 @@ var tusClientReducer = function tusClientReducer(state, actions) {
         });
       }
 
-    case 'UPDATE_SUCCESS_UPLOAD':
+    case "UPDATE_SUCCESS_UPLOAD":
       {
         var _cacheKey2 = actions.payload.cacheKey;
         var target = state.uploads[_cacheKey2];
@@ -570,7 +530,7 @@ var tusClientReducer = function tusClientReducer(state, actions) {
         });
       }
 
-    case 'UPDATE_ERROR_UPLOAD':
+    case "UPDATE_ERROR_UPLOAD":
       {
         var _actions$payload2 = actions.payload,
             _cacheKey3 = _actions$payload2.cacheKey,
@@ -588,7 +548,7 @@ var tusClientReducer = function tusClientReducer(state, actions) {
         });
       }
 
-    case 'UPDATE_IS_ABORTED_UPLOAD':
+    case "UPDATE_IS_ABORTED_UPLOAD":
       {
         var _actions$payload3 = actions.payload,
             _cacheKey4 = _actions$payload3.cacheKey,
@@ -606,7 +566,7 @@ var tusClientReducer = function tusClientReducer(state, actions) {
         });
       }
 
-    case 'REMOVE_UPLOAD_INSTANCE':
+    case "REMOVE_UPLOAD_INSTANCE":
       {
         var _cacheKey5 = actions.payload.cacheKey;
         var newUploads = state.uploads;
@@ -616,24 +576,11 @@ var tusClientReducer = function tusClientReducer(state, actions) {
         });
       }
 
-    case 'RESET_CLIENT':
+    case "UPDATE_DEFAULT_OPTIONS":
       {
-        return {
-          tusHandler: new TusHandler(),
-          uploads: {}
-        };
-      }
-
-    case 'UPDATE_TUS_HANDLER_OPTIONS':
-      {
-        var _actions$payload4 = actions.payload,
-            canStoreURLs = _actions$payload4.canStoreURLs,
-            defaultOptions = _actions$payload4.defaultOptions;
+        var defaultOptions = actions.payload.defaultOptions;
         return _objectSpread2(_objectSpread2({}, state), {}, {
-          tusHandler: new TusHandler({
-            canStoreURLs: canStoreURLs,
-            defaultOptions: defaultOptions
-          })
+          defaultOptions: defaultOptions
         });
       }
 
@@ -643,62 +590,37 @@ var tusClientReducer = function tusClientReducer(state, actions) {
 };
 var tusClientInitialState = {
   uploads: {},
-  tusHandler: new TusHandler()
+  defaultOptions: undefined
 };
 
-var TusController = function TusController(_ref) {
-  var canStoreURLs = _ref.canStoreURLs,
-      _ref$defaultOptions = _ref.defaultOptions,
-      defaultOptions = _ref$defaultOptions === void 0 ? initialDefaultOptions : _ref$defaultOptions,
+var TusClientProvider = function TusClientProvider(_ref) {
+  var defaultOptions = _ref.defaultOptions,
       children = _ref.children;
 
-  var _useTusClientState = useTusClientState(),
-      tusHandler = _useTusClientState.tusHandler;
+  var _useReducer = react.useReducer(tusClientReducer, _objectSpread2(_objectSpread2({}, tusClientInitialState), {}, {
+    defaultOptions: defaultOptions
+  })),
+      _useReducer2 = _slicedToArray(_useReducer, 2),
+      tusClientState = _useReducer2[0],
+      tusClientDispatch = _useReducer2[1];
 
-  var tus = tusHandler.getTus;
-  var tusClientDispatch = useTusClientDispatch();
   react.useEffect(function () {
-    if (tusHandler.getTus.isSupported || process.env.NODE_ENV === 'production') {
+    if (tusJsClient.isSupported || process.env.NODE_ENV === "production") {
       return;
     }
 
     console.error(ERROR_MESSAGES.tusIsNotSupported);
-  }, [tusHandler.getTus.isSupported]);
+  }, []);
   react.useEffect(function () {
-    if (tus.defaultOptions === defaultOptions && tus.canStoreURLs === canStoreURLs) {
+    if (tusClientState.defaultOptions === defaultOptions) {
       return;
     }
 
-    tusClientDispatch(updateTusHandlerOptions({
-      canStoreURLs: canStoreURLs,
-      defaultOptions: defaultOptions
-    }));
-  }, [tusClientDispatch, canStoreURLs, defaultOptions, tus.canStoreURLs, tus.defaultOptions]);
-  return react.createElement(react.Fragment, {}, children);
-};
-
-var TusClientProvider = function TusClientProvider(_ref) {
-  var canStoreURLs = _ref.canStoreURLs,
-      defaultOptions = _ref.defaultOptions,
-      children = _ref.children;
-
-  var _useReducer = react.useReducer(tusClientReducer, _objectSpread2(_objectSpread2({}, tusClientInitialState), {}, {
-    tusHandler: new TusHandler({
-      canStoreURLs: canStoreURLs,
-      defaultOptions: defaultOptions
-    })
-  })),
-      _useReducer2 = _slicedToArray(_useReducer, 2),
-      tusClientState = _useReducer2[0],
-      tusClientDispatch = _useReducer2[1];
-
-  var tusControllerElement = react.createElement(TusController, {
-    canStoreURLs: canStoreURLs,
-    defaultOptions: defaultOptions
-  }, children);
+    tusClientDispatch(updateDefaultOptions(defaultOptions));
+  }, [defaultOptions, tusClientState.defaultOptions]);
   var tusClientDispatchContextProviderElement = react.createElement(TusClientDispatchContext.Provider, {
     value: tusClientDispatch
-  }, tusControllerElement);
+  }, children);
   return react.createElement(TusClientStateContext.Provider, {
     value: tusClientState
   }, tusClientDispatchContextProviderElement);
@@ -706,3 +628,4 @@ var TusClientProvider = function TusClientProvider(_ref) {
 
 exports.TusClientProvider = TusClientProvider;
 exports.useTus = useTus;
+exports.useTusStore = useTusStore;