use-tus 0.5.0 → 0.7.0

package/dist/index.js

@@ -1,24 +1,137 @@
-import { createContext, useMemo, useContext, useState, useCallback, useEffect, createElement, Fragment, useReducer } from 'react';
-import * as tus from 'tus-js-client';
-import { Upload } from 'tus-js-client';
+import { useEffect, useMemo, useState, useCallback, createContext, useContext, useReducer, createElement } from 'react';
+import { Upload, isSupported } from 'tus-js-client';
+
+const createUpload = (file, options, dispatchIsAborted) => {
+    const upload = new Upload(file, options);
+    const originalStart = upload.start.bind(upload);
+    const originalAbort = upload.abort.bind(upload);
+    const start = () => {
+        originalStart();
+        dispatchIsAborted(false);
+    };
+    const abort = async () => {
+        originalAbort();
+        dispatchIsAborted(true);
+    };
+    upload.start = start;
+    upload.abort = abort;
+    return { upload, originalStart, originalAbort };
+};
+
+const startOrResumeUpload = (upload) => {
+    upload.findPreviousUploads().then((previousUploads) => {
+        if (previousUploads.length) {
+            upload.resumeFromPreviousUpload(previousUploads[0]);
+        }
+        upload.start();
+    });
+};
+
+const useAutoAbort = (upload, abort, autoAbort) => {
+    useEffect(() => {
+        const abortUploading = async () => {
+            if (!upload || !abort) {
+                return;
+            }
+            await abort();
+        };
+        return () => {
+            if (!autoAbort) {
+                return;
+            }
+            abortUploading();
+        };
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [autoAbort, upload]);
+};
+
+const defaultUseTusOptionsValue = Object.freeze({
+    autoAbort: true,
+    autoStart: false,
+});
+const useMergeTusOptions = (options) => useMemo(() => ({
+    ...defaultUseTusOptionsValue,
+    ...(options || {}),
+}), [options]);
+
+const initialUseTusState = Object.freeze({
+    upload: undefined,
+    isSuccess: false,
+    isAborted: false,
+    error: undefined,
+    originalAbort: undefined,
+});
+const useTus = (baseOption) => {
+    const { autoAbort, autoStart, uploadOptions } = useMergeTusOptions(baseOption);
+    const [tusState, setTusState] = useState(initialUseTusState);
+    const updateTusState = useCallback((newOptions) => {
+        setTusState((tus) => ({
+            ...tus,
+            ...newOptions,
+        }));
+    }, []);
+    const setUpload = useCallback((file, options = {}) => {
+        const targetOptions = {
+            ...uploadOptions,
+            ...options,
+        };
+        const onSuccess = () => {
+            updateTusState({ isSuccess: true });
+            targetOptions?.onSuccess?.();
+        };
+        const onError = (error) => {
+            updateTusState({ error });
+            targetOptions?.onError?.(error);
+        };
+        const mergedUploadOptions = {
+            ...targetOptions,
+            onSuccess,
+            onError,
+        };
+        const dispatchIsAborted = (isAborted) => {
+            updateTusState({ isAborted });
+        };
+        const { upload, originalAbort } = createUpload(file, mergedUploadOptions, dispatchIsAborted);
+        if (autoStart) {
+            startOrResumeUpload(upload);
+        }
+        updateTusState({ ...initialUseTusState, upload, originalAbort });
+    }, [autoStart, updateTusState, uploadOptions]);
+    const remove = useCallback(() => {
+        // `upload.abort` function will set `isAborted` state.
+        // So call the original function for restore state.
+        tusState?.originalAbort?.();
+        setTusState(initialUseTusState);
+    }, [tusState]);
+    const tusResult = useMemo(() => ({
+        upload: tusState?.upload,
+        isSuccess: tusState?.isSuccess ?? false,
+        error: tusState?.error,
+        isAborted: tusState?.isAborted ?? false,
+        setUpload,
+        remove,
+    }), [tusState, setUpload, remove]);
+    useAutoAbort(tusResult.upload, tusState.originalAbort, autoAbort ?? false);
+    return tusResult;
+};
 
 const 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.",
 };
 
 const TusClientStateContext = createContext(undefined);
 const TusClientDispatchContext = createContext(undefined);
 const useTusClientState = () => {
     const tusClientState = useContext(TusClientStateContext);
-    if (!tusClientState && process.env.NODE_ENV !== 'production') {
+    if (!tusClientState && process.env.NODE_ENV !== "production") {
         throw new Error(ERROR_MESSAGES.tusClientHasNotFounded);
     }
     return useMemo(() => tusClientState, [tusClientState]);
 };
 const useTusClientDispatch = () => {
     const tusClientDispatch = useContext(TusClientDispatchContext);
-    if (!tusClientDispatch && process.env.NODE_ENV !== 'production') {
+    if (!tusClientDispatch && process.env.NODE_ENV !== "production") {
         throw new Error(ERROR_MESSAGES.tusClientHasNotFounded);
     }
     return useMemo(() => tusClientDispatch, [
@@ -27,7 +140,7 @@ const useTusClientDispatch = () => {
 };
 
 const insertUploadInstance = (cacheKey, upload) => ({
-    type: 'INSERT_UPLOAD_INSTANCE',
+    type: "INSERT_UPLOAD_INSTANCE",
     payload: {
         cacheKey,
         uploadState: {
@@ -38,164 +151,73 @@ const insertUploadInstance = (cacheKey, upload) => ({
     },
 });
 const updateSuccessUpload = (cacheKey) => ({
-    type: 'UPDATE_SUCCESS_UPLOAD',
+    type: "UPDATE_SUCCESS_UPLOAD",
     payload: {
         cacheKey,
     },
 });
 const updateErrorUpload = (cacheKey, error) => ({
-    type: 'UPDATE_ERROR_UPLOAD',
+    type: "UPDATE_ERROR_UPLOAD",
     payload: {
         cacheKey,
         error,
     },
 });
 const updateIsAbortedUpload = (cacheKey, isAborted) => ({
-    type: 'UPDATE_IS_ABORTED_UPLOAD',
+    type: "UPDATE_IS_ABORTED_UPLOAD",
     payload: {
         cacheKey,
         isAborted,
     },
 });
 const removeUploadInstance = (cacheKey) => ({
-    type: 'REMOVE_UPLOAD_INSTANCE',
+    type: "REMOVE_UPLOAD_INSTANCE",
     payload: {
         cacheKey,
     },
 });
-const updateTusHandlerOptions = (payload) => ({
-    type: 'UPDATE_TUS_HANDLER_OPTIONS',
-    payload,
+const updateDefaultOptions = (defaultOptions) => ({
+    type: "UPDATE_DEFAULT_OPTIONS",
+    payload: {
+        defaultOptions,
+    },
 });
 
-const createOptionHandler = (handlers, { dispatch, internalDispatch, cacheKey }) => {
-    const onSuccess = () => {
-        if (cacheKey) {
-            dispatch(updateSuccessUpload(cacheKey));
-        }
-        if (!cacheKey) {
-            internalDispatch((internalTusState) => ({
-                ...internalTusState,
-                isSuccess: true,
-            }));
-        }
-        if (handlers.onSuccess) {
-            handlers.onSuccess();
-        }
-    };
-    const onError = (err) => {
-        if (cacheKey) {
-            dispatch(updateErrorUpload(cacheKey, err));
-        }
-        if (!cacheKey) {
-            internalDispatch((internalTusState) => ({
-                ...internalTusState,
-                error: err,
-            }));
-        }
-        if (handlers.onError) {
-            handlers.onError(err);
-        }
-    };
-    return {
-        onSuccess,
-        onError,
-    };
-};
-const startOrResumeUpload = (upload) => {
-    upload.findPreviousUploads().then((previousUploads) => {
-        if (previousUploads.length) {
-            upload.resumeFromPreviousUpload(previousUploads[0]);
-        }
-        upload.start();
-    });
-};
-const createUpload = (file, options, { dispatch, internalDispatch, cacheKey }) => {
-    const upload = new Upload(file, options);
-    const originalStart = upload.start.bind(upload);
-    const originalAbort = upload.abort.bind(upload);
-    const dispatchIsAborted = (isAborted) => {
-        if (cacheKey) {
-            dispatch(updateIsAbortedUpload(cacheKey, isAborted));
-            return;
-        }
-        internalDispatch((internalTusState) => ({
-            ...internalTusState,
-            isAborted,
-        }));
-    };
-    const start = () => {
-        originalStart();
-        dispatchIsAborted(false);
-    };
-    const abort = async () => {
-        originalAbort();
-        dispatchIsAborted(true);
-    };
-    upload.start = start;
-    upload.abort = abort;
-    return upload;
-};
-
-const defaultUseTusOptionsValue = Object.freeze({
-    cacheKey: undefined,
-    autoAbort: true,
-    autoStart: false,
-});
-const initialUseTusState = Object.freeze({
-    upload: undefined,
-    isSuccess: false,
-    isAborted: false,
-    error: undefined,
-});
-const useTus = (useTusOptions) => {
-    const { cacheKey, autoAbort, autoStart } = {
-        ...defaultUseTusOptionsValue,
-        ...(useTusOptions || {}),
-    };
-    const [internalTusState, setInternalTusState] = useState(initialUseTusState);
-    const tusClientState = useTusClientState();
+const useTusStore = (cacheKey, baseOption) => {
+    const { autoAbort, autoStart, uploadOptions } = useMergeTusOptions(baseOption);
+    const { defaultOptions, uploads } = useTusClientState();
     const tusClientDispatch = useTusClientDispatch();
-    const tus = tusClientState.tusHandler.getTus;
     const setUpload = useCallback((file, options = {}) => {
-        const dispatcher = {
-            cacheKey,
-            dispatch: tusClientDispatch,
-            internalDispatch: setInternalTusState,
-        };
         const targetOptions = {
-            ...tus.defaultOptions(file),
+            ...defaultOptions?.(file),
+            ...uploadOptions,
             ...options,
         };
-        const { onSuccess, onError } = createOptionHandler({
-            onError: targetOptions.onError,
-            onSuccess: targetOptions.onSuccess,
-        }, dispatcher);
-        const uploadOptions = {
+        const onSuccess = () => {
+            tusClientDispatch(updateSuccessUpload(cacheKey));
+            targetOptions?.onSuccess?.();
+        };
+        const onError = (error) => {
+            tusClientDispatch(updateErrorUpload(cacheKey, error));
+            targetOptions?.onError?.(error);
+        };
+        const mergedUploadOptions = {
             ...targetOptions,
             onSuccess,
             onError,
         };
-        const upload = createUpload(file, uploadOptions, dispatcher);
+        const dispatchIsAborted = (isAborted) => {
+            tusClientDispatch(updateIsAbortedUpload(cacheKey, isAborted));
+        };
+        const { upload } = createUpload(file, mergedUploadOptions, dispatchIsAborted);
         if (autoStart) {
             startOrResumeUpload(upload);
         }
-        if (cacheKey) {
-            tusClientDispatch(insertUploadInstance(cacheKey, upload));
-            return;
-        }
-        setInternalTusState({
-            ...initialUseTusState,
-            upload,
-        });
-    }, [tusClientDispatch, cacheKey, tus, autoStart]);
-    const targetTusState = useMemo(() => (cacheKey ? tusClientState.uploads[cacheKey] : internalTusState), [cacheKey, tusClientState, internalTusState]);
+        tusClientDispatch(insertUploadInstance(cacheKey, upload));
+    }, [autoStart, cacheKey, defaultOptions, tusClientDispatch, uploadOptions]);
+    const targetTusState = useMemo(() => uploads[cacheKey], [cacheKey, uploads]);
     const remove = useCallback(() => {
         targetTusState?.upload?.abort();
-        if (!cacheKey) {
-            setInternalTusState(initialUseTusState);
-            return;
-        }
         tusClientDispatch(removeUploadInstance(cacheKey));
     }, [targetTusState, tusClientDispatch, cacheKey]);
     const tusResult = useMemo(() => ({
@@ -206,42 +228,13 @@ const useTus = (useTusOptions) => {
         setUpload,
         remove,
     }), [targetTusState, setUpload, remove]);
-    // For autoAbort option
-    useEffect(() => {
-        const abortUploading = async () => {
-            if (!tusResult.upload) {
-                return;
-            }
-            await tusResult.upload.abort();
-        };
-        return () => {
-            if (!autoAbort) {
-                return;
-            }
-            abortUploading();
-        };
-    }, [autoAbort, tusResult.upload]);
+    useAutoAbort(tusResult.upload, tusResult.upload?.abort, autoAbort ?? false);
     return tusResult;
 };
 
-const initialDefaultOptions = () => tus.defaultOptions;
-class TusHandler {
-    constructor(tusConfigs) {
-        const { canStoreURLs = tus.canStoreURLs, defaultOptions = initialDefaultOptions, } = tusConfigs || {};
-        this.tus = {
-            ...tus,
-            canStoreURLs,
-            defaultOptions,
-        };
-    }
-    get getTus() {
-        return this.tus;
-    }
-}
-
 const tusClientReducer = (state, actions) => {
     switch (actions.type) {
-        case 'INSERT_UPLOAD_INSTANCE': {
+        case "INSERT_UPLOAD_INSTANCE": {
             const { cacheKey, uploadState } = actions.payload;
             return {
                 ...state,
@@ -251,7 +244,7 @@ const tusClientReducer = (state, actions) => {
                 },
             };
         }
-        case 'UPDATE_SUCCESS_UPLOAD': {
+        case "UPDATE_SUCCESS_UPLOAD": {
             const { cacheKey } = actions.payload;
             const target = state.uploads[cacheKey];
             if (!target) {
@@ -268,7 +261,7 @@ const tusClientReducer = (state, actions) => {
                 },
             };
         }
-        case 'UPDATE_ERROR_UPLOAD': {
+        case "UPDATE_ERROR_UPLOAD": {
             const { cacheKey, error } = actions.payload;
             const target = state.uploads[cacheKey];
             if (!target) {
@@ -285,7 +278,7 @@ const tusClientReducer = (state, actions) => {
                 },
             };
         }
-        case 'UPDATE_IS_ABORTED_UPLOAD': {
+        case "UPDATE_IS_ABORTED_UPLOAD": {
             const { cacheKey, isAborted } = actions.payload;
             const target = state.uploads[cacheKey];
             if (!target) {
@@ -302,7 +295,7 @@ const tusClientReducer = (state, actions) => {
                 },
             };
         }
-        case 'REMOVE_UPLOAD_INSTANCE': {
+        case "REMOVE_UPLOAD_INSTANCE": {
             const { cacheKey } = actions.payload;
             const newUploads = state.uploads;
             delete newUploads[cacheKey];
@@ -311,20 +304,11 @@ const tusClientReducer = (state, actions) => {
                 uploads: newUploads,
             };
         }
-        case 'RESET_CLIENT': {
-            return {
-                tusHandler: new TusHandler(),
-                uploads: {},
-            };
-        }
-        case 'UPDATE_TUS_HANDLER_OPTIONS': {
-            const { canStoreURLs, defaultOptions } = actions.payload;
+        case "UPDATE_DEFAULT_OPTIONS": {
+            const { defaultOptions } = actions.payload;
             return {
                 ...state,
-                tusHandler: new TusHandler({
-                    canStoreURLs,
-                    defaultOptions,
-                }),
+                defaultOptions,
             };
         }
         default:
@@ -333,53 +317,33 @@ const tusClientReducer = (state, actions) => {
 };
 const tusClientInitialState = {
     uploads: {},
-    tusHandler: new TusHandler(),
+    defaultOptions: undefined,
 };
 
-const TusController = ({ canStoreURLs, defaultOptions = initialDefaultOptions, children, }) => {
-    const { tusHandler } = useTusClientState();
-    const tus = tusHandler.getTus;
-    const tusClientDispatch = useTusClientDispatch();
+const TusClientProvider = ({ defaultOptions, children, }) => {
+    const [tusClientState, tusClientDispatch] = useReducer(tusClientReducer, {
+        ...tusClientInitialState,
+        defaultOptions,
+    });
+    // Output error if tus has not supported
     useEffect(() => {
-        if (tusHandler.getTus.isSupported ||
-            process.env.NODE_ENV === 'production') {
+        if (isSupported || process.env.NODE_ENV === "production") {
             return;
         }
         // eslint-disable-next-line no-console
         console.error(ERROR_MESSAGES.tusIsNotSupported);
-    }, [tusHandler.getTus.isSupported]);
+    }, []);
+    // Set defaultOptions to the context
     useEffect(() => {
-        if (tus.defaultOptions === defaultOptions &&
-            tus.canStoreURLs === canStoreURLs) {
+        if (tusClientState.defaultOptions === defaultOptions) {
             return;
         }
-        tusClientDispatch(updateTusHandlerOptions({ canStoreURLs, defaultOptions }));
-    }, [
-        tusClientDispatch,
-        canStoreURLs,
-        defaultOptions,
-        tus.canStoreURLs,
-        tus.defaultOptions,
-    ]);
-    return createElement(Fragment, {}, children);
-};
-
-const TusClientProvider = ({ canStoreURLs, defaultOptions, children, }) => {
-    const [tusClientState, tusClientDispatch] = useReducer(tusClientReducer, {
-        ...tusClientInitialState,
-        tusHandler: new TusHandler({
-            canStoreURLs,
-            defaultOptions,
-        }),
-    });
-    const tusControllerElement = createElement(TusController, {
-        canStoreURLs,
-        defaultOptions,
-    }, children);
-    const tusClientDispatchContextProviderElement = createElement(TusClientDispatchContext.Provider, { value: tusClientDispatch }, tusControllerElement);
+        tusClientDispatch(updateDefaultOptions(defaultOptions));
+    }, [defaultOptions, tusClientState.defaultOptions]);
+    const tusClientDispatchContextProviderElement = createElement(TusClientDispatchContext.Provider, { value: tusClientDispatch }, children);
     return createElement(TusClientStateContext.Provider, {
         value: tusClientState,
     }, tusClientDispatchContextProviderElement);
 };
 
-export { TusClientProvider, useTus };
+export { TusClientProvider, useTus, useTusStore };

package/dist/useTus/index.d.ts

@@ -1,2 +1,3 @@
-export { useTus } from './useTus';
-export type { UseTusResult, UseTusOptions } from './types';
+export { useTus } from "./useTus";
+export { useTusStore } from "./useTusStore";
+export type { UseTusResult, UseTusOptions } from "./types";

package/dist/useTus/types.d.ts

@@ -1,15 +1,14 @@
-import type { Upload } from 'tus-js-client';
-export declare type UseTusOptions = {
-    cacheKey?: string;
+import type { Upload, UploadOptions } from "tus-js-client";
+export interface UseTusOptions {
     autoAbort?: boolean;
     autoStart?: boolean;
-};
-export declare type UseTusResult = {
+    uploadOptions?: UploadOptions;
+}
+export interface UseTusResult {
     upload?: Upload;
-    setUpload: (file: Upload['file'], options?: Upload['options']) => void;
-    remove: () => void;
+    setUpload: (file: Upload["file"], options?: Upload["options"]) => void;
     isSuccess: boolean;
     isAborted: boolean;
     error?: Error;
-};
-export declare type UseTusState = Pick<UseTusResult, 'upload' | 'isSuccess' | 'error' | 'isAborted'>;
+    remove: () => void;
+}

package/dist/useTus/useTus.d.ts

@@ -1,2 +1,2 @@
-import { UseTusOptions, UseTusResult } from './types';
-export declare const useTus: (useTusOptions?: UseTusOptions | undefined) => UseTusResult;
+import { UseTusOptions, UseTusResult } from "./types";
+export declare const useTus: (baseOption?: UseTusOptions) => UseTusResult;

package/dist/useTus/useTusStore.d.ts

@@ -0,0 +1,2 @@
+import { UseTusOptions, UseTusResult } from "./types";
+export declare const useTusStore: (cacheKey: string, baseOption?: UseTusOptions) => UseTusResult;

package/dist/useTus/utils/createUpload.d.ts

@@ -0,0 +1,7 @@
+import { Upload } from "tus-js-client";
+export declare type DispatchIsAborted = (isAborted: boolean) => void;
+export declare const createUpload: (file: Upload["file"], options: Upload["options"], dispatchIsAborted: DispatchIsAborted) => {
+    upload: Upload;
+    originalStart: () => void;
+    originalAbort: (shouldTerminate?: boolean | undefined) => Promise<void>;
+};

package/dist/useTus/utils/startOrResumeUpload.d.ts

@@ -0,0 +1,2 @@
+import { Upload } from "tus-js-client";
+export declare const startOrResumeUpload: (upload: Upload) => void;

package/dist/useTus/utils/useAutoAbort.d.ts

@@ -0,0 +1,2 @@
+import { Upload } from "tus-js-client";
+export declare const useAutoAbort: (upload: Upload | undefined, abort: Upload["abort"] | undefined, autoAbort: boolean) => void;

package/dist/useTus/utils/useMergeTusOptions.d.ts

@@ -0,0 +1,6 @@
+import { UseTusOptions } from "../types";
+export declare const useMergeTusOptions: (options: UseTusOptions | undefined) => {
+    autoAbort?: boolean | undefined;
+    autoStart?: boolean | undefined;
+    uploadOptions?: import("tus-js-client").UploadOptions | undefined;
+};

package/dist/useTusClient/index.d.ts

@@ -1 +1 @@
-export { useTusClient } from './useTusClient';
+export { useTusClient } from "./useTusClient";

package/dist/useTusClient/useTusClient.d.ts

@@ -1,6 +1,6 @@
 export declare const useTusClient: () => {
     state: {
-        [cacheKey: string]: import("../core/tusClientReducer").UploadState | undefined;
+        [cacheKey: string]: import("../TusClientProvider/store/tusClientReducer").UploadState | undefined;
     };
     removeUpload: (cacheKey: string) => void;
     reset: () => void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "use-tus",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "React hooks for resumable file uploads using tus-js-client",
   "main": "dist/index.cjs.js",
   "module": "dist/index.esm.js",
@@ -11,8 +11,8 @@
     "test": "cross-env NODE_ENV=TEST jest",
     "type": "tsc --noEmit",
     "format": "npm-run-all -s format:*",
-    "format:fix": "prettier --write './src/**/*.{ts,tsx,js,jsx,json}'",
-    "format:lint": "eslint ./src --ext .ts,.tsx",
+    "format:fix": "prettier --write './**/*.{ts,tsx,js,jsx,json}'",
+    "format:lint": "eslint ./ --ext .ts,.tsx",
     "clean": "rimraf ./dist",
     "prepublishOnly": "npm run build",
     "prepare": "husky install",
@@ -59,8 +59,7 @@
     "@storybook/addon-links": "^6.2.9",
     "@storybook/react": "^6.2.9",
     "@testing-library/jest-dom": "^5.11.10",
-    "@testing-library/react": "^11.2.6",
-    "@testing-library/react-hooks": "^5.1.1",
+    "@testing-library/react": "^13.3.0",
     "@types/jest": "^26.0.22",
     "@types/react": "^17.0.3",
     "@types/react-dom": "^17.0.3",
@@ -87,17 +86,17 @@
     "npm-run-all": "^4.1.5",
     "postcss": "^7",
     "prettier": "^2.2.1",
-    "react": "^17.0.2",
-    "react-dom": "^17.0.2",
+    "react": "^18.1.0",
+    "react-dom": "^18.1.0",
     "rimraf": "^3.0.2",
     "rollup": "^2.44.0",
     "tailwindcss": "npm:@tailwindcss/postcss7-compat",
     "ts-jest": "^26.5.4",
-    "typescript": "^4.2.3",
-    "tus-js-client": "^2.2.0"
+    "tus-js-client": "^2.2.0",
+    "typescript": "^4.7.3"
   },
   "peerDependencies": {
-    "react": "^16.8.0 || ^17.0.0",
+    "react": ">=16.8",
     "tus-js-client": "^2.2.0"
   },
   "dependencies": {}

package/dist/TusClientProvider/TusController.d.ts

@@ -1,4 +0,0 @@
-import { FC } from 'react';
-import { TusConfigs } from '../core/tusHandler';
-export declare type TusControllerProps = Readonly<TusConfigs>;
-export declare const TusController: FC<TusControllerProps>;

package/dist/core/constants.d.ts

@@ -1,4 +0,0 @@
-export declare const ERROR_MESSAGES: {
-    tusClientHasNotFounded: string;
-    tusIsNotSupported: string;
-};