@aws-amplify/ui-react-storage 3.3.2 → 3.3.4

package/dist/index.js

@@ -33,7 +33,7 @@ function _interopNamespace(e) {
 var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-var FileStatus$1;
+var FileStatus;
 (function (FileStatus) {
     FileStatus["ADDED"] = "added";
     FileStatus["QUEUED"] = "queued";
@@ -41,21 +41,22 @@ var FileStatus$1;
     FileStatus["PAUSED"] = "paused";
     FileStatus["ERROR"] = "error";
     FileStatus["UPLOADED"] = "uploaded";
-})(FileStatus$1 || (FileStatus$1 = {}));
+})(FileStatus || (FileStatus = {}));
 
 var FileUploaderActionTypes;
 (function (FileUploaderActionTypes) {
-    FileUploaderActionTypes["ADD_FILES"] = "ADD_FILES";
-    FileUploaderActionTypes["CLEAR_FILES"] = "CLEAR_FILES";
-    FileUploaderActionTypes["QUEUE_FILES"] = "QUEUE_FILES";
-    FileUploaderActionTypes["SET_STATUS"] = "SET_STATUS";
-    FileUploaderActionTypes["SET_PROCESSED_FILE_KEY"] = "SET_PROCESSED_FILE_KEY";
-    FileUploaderActionTypes["SET_STATUS_UPLOADING"] = "SET_STATUS_UPLOADING";
-    FileUploaderActionTypes["SET_UPLOAD_PROGRESS"] = "SET_UPLOAD_PROGRESS";
-    FileUploaderActionTypes["REMOVE_UPLOAD"] = "REMOVE_UPLOAD";
+    FileUploaderActionTypes[FileUploaderActionTypes["ADD_FILES"] = 0] = "ADD_FILES";
+    FileUploaderActionTypes[FileUploaderActionTypes["CLEAR_FILES"] = 1] = "CLEAR_FILES";
+    FileUploaderActionTypes[FileUploaderActionTypes["QUEUE_FILES"] = 2] = "QUEUE_FILES";
+    FileUploaderActionTypes[FileUploaderActionTypes["REMOVE_UPLOAD"] = 3] = "REMOVE_UPLOAD";
+    FileUploaderActionTypes[FileUploaderActionTypes["SET_STATUS"] = 4] = "SET_STATUS";
+    FileUploaderActionTypes[FileUploaderActionTypes["SET_PROCESSED_FILE_KEY"] = 5] = "SET_PROCESSED_FILE_KEY";
+    FileUploaderActionTypes[FileUploaderActionTypes["SET_STATUS_UPLOADED"] = 6] = "SET_STATUS_UPLOADED";
+    FileUploaderActionTypes[FileUploaderActionTypes["SET_STATUS_UPLOADING"] = 7] = "SET_STATUS_UPLOADING";
+    FileUploaderActionTypes[FileUploaderActionTypes["SET_UPLOAD_PROGRESS"] = 8] = "SET_UPLOAD_PROGRESS";
 })(FileUploaderActionTypes || (FileUploaderActionTypes = {}));
 
-const updateFiles$1 = (files, nextFileData) => files.reduce((files, currentFile) => {
+const updateFiles = (files, nextFileData) => files.reduce((files, currentFile) => {
     if (currentFile.id === nextFileData.id) {
         return [...files, { ...currentFile, ...nextFileData }];
     }
@@ -74,7 +75,7 @@ function fileUploaderStateReducer(state, action) {
                     file,
                     error: errorText,
                     key: file.name,
-                    status: errorText ? FileStatus$1.ERROR : status,
+                    status: errorText ? FileStatus.ERROR : status,
                     isImage: file.type.startsWith('image/'),
                     progress: -1,
                 };
@@ -87,155 +88,132 @@ function fileUploaderStateReducer(state, action) {
         }
         case FileUploaderActionTypes.QUEUE_FILES: {
             const { files } = state;
-            const newFiles = files.reduce((files, currentFile) => {
-                return [
-                    ...files,
-                    {
-                        ...currentFile,
-                        ...(currentFile.status === FileStatus$1.ADDED
-                            ? { status: FileStatus$1.QUEUED }
-                            : {}),
-                    },
-                ];
-            }, []);
-            return {
-                ...state,
-                files: newFiles,
-            };
+            const newFiles = files.reduce((files, currentFile) => [
+                ...files,
+                {
+                    ...currentFile,
+                    ...(currentFile.status === FileStatus.ADDED
+                        ? { status: FileStatus.QUEUED }
+                        : {}),
+                },
+            ], []);
+            return { ...state, files: newFiles };
         }
         case FileUploaderActionTypes.SET_STATUS_UPLOADING: {
             const { id, uploadTask } = action;
-            const status = FileStatus$1.UPLOADING;
+            const status = FileStatus.UPLOADING;
             const progress = 0;
             const nextFileData = { status, progress, id, uploadTask };
-            const files = updateFiles$1(state.files, nextFileData);
+            const files = updateFiles(state.files, nextFileData);
             return { ...state, files };
         }
-        case FileUploaderActionTypes.SET_PROCESSED_FILE_KEY: {
-            const { processedKey, id } = action;
-            const files = updateFiles$1(state.files, { processedKey, id });
-            return { files };
+        case FileUploaderActionTypes.SET_STATUS_UPLOADED: {
+            const files = updateFiles(state.files, action);
+            return { ...state, files };
         }
         case FileUploaderActionTypes.SET_UPLOAD_PROGRESS: {
             const { id, progress } = action;
-            const files = updateFiles$1(state.files, { id, progress });
+            const files = updateFiles(state.files, { id, progress });
             return { ...state, files };
         }
         case FileUploaderActionTypes.SET_STATUS: {
             const { id, status } = action;
-            const files = updateFiles$1(state.files, { id, status });
+            const files = updateFiles(state.files, { id, status });
             return { ...state, files };
         }
         case FileUploaderActionTypes.REMOVE_UPLOAD: {
             const { id } = action;
             const { files } = state;
             const newFiles = files.reduce((files, currentFile) => {
-                if (currentFile.id === id) {
-                    // remove by not returning currentFile
-                    return [...files];
-                }
-                return [...files, currentFile];
+                // remove by not returning currentFile
+                return currentFile.id === id ? [...files] : [...files, currentFile];
             }, []);
-            return {
-                ...state,
-                files: newFiles,
-            };
+            return { ...state, files: newFiles };
         }
     }
 }
 
-const addFilesAction$1 = ({ files, status, getFileErrorMessage, }) => ({
+const addFilesAction = ({ files, status, getFileErrorMessage, }) => ({
     type: FileUploaderActionTypes.ADD_FILES,
     files,
     status,
     getFileErrorMessage,
 });
-const clearFilesAction$1 = () => ({
+const clearFilesAction = () => ({
     type: FileUploaderActionTypes.CLEAR_FILES,
 });
-const queueFilesAction$1 = () => ({
+const queueFilesAction = () => ({
     type: FileUploaderActionTypes.QUEUE_FILES,
 });
-const setProcessedKeyAction$1 = (input) => ({
-    ...input,
-    type: FileUploaderActionTypes.SET_PROCESSED_FILE_KEY,
-});
-const setUploadingFileAction$1 = ({ id, uploadTask, }) => ({
+const setUploadingFileAction = ({ id, uploadTask, }) => ({
     type: FileUploaderActionTypes.SET_STATUS_UPLOADING,
     id,
     uploadTask,
 });
-const setUploadProgressAction$1 = ({ id, progress, }) => ({
+const setUploadProgressAction = ({ id, progress, }) => ({
     type: FileUploaderActionTypes.SET_UPLOAD_PROGRESS,
     id,
     progress,
 });
-const setUploadStatusAction$1 = ({ id, status, }) => ({
+const setUploadStatusAction = ({ id, status, }) => ({
     type: FileUploaderActionTypes.SET_STATUS,
     id,
     status,
 });
-const removeUploadAction$1 = ({ id }) => ({
+const setUploadSuccessAction = ({ id, resolvedKey, }) => ({
+    type: FileUploaderActionTypes.SET_STATUS_UPLOADED,
+    id,
+    resolvedKey,
+    status: FileStatus.UPLOADED,
+});
+const removeUploadAction = ({ id }) => ({
     type: FileUploaderActionTypes.REMOVE_UPLOAD,
     id,
 });
 
-const isDefaultFile$1 = (file) => !!(ui.isObject(file) && file.key);
-const createFileFromDefault$1 = (file) => isDefaultFile$1(file)
-    ? { ...file, id: file.key, status: FileStatus$1.UPLOADED }
+const isDefaultFile = (file) => !!(ui.isObject(file) && file.key);
+const createFileFromDefault = (file) => isDefaultFile(file)
+    ? { ...file, id: file.key, status: FileStatus.UPLOADED }
     : undefined;
 function useFileUploader(defaultFiles = []) {
     const [{ files }, dispatch] = React__default["default"].useReducer(fileUploaderStateReducer, {
         files: (Array.isArray(defaultFiles)
-            ? defaultFiles.map(createFileFromDefault$1).filter((file) => !!file)
+            ? defaultFiles.map(createFileFromDefault).filter((file) => !!file)
             : []),
     });
-    const addFiles = ({ files, status, getFileErrorMessage, }) => {
-        dispatch(addFilesAction$1({ files, status, getFileErrorMessage }));
-    };
-    const clearFiles = () => {
-        dispatch(clearFilesAction$1());
-    };
-    const queueFiles = () => {
-        dispatch(queueFilesAction$1());
-    };
-    const setUploadingFile = ({ uploadTask, id, }) => {
-        dispatch(setUploadingFileAction$1({ id, uploadTask }));
-    };
-    const setProcessedKey = (input) => {
-        dispatch(setProcessedKeyAction$1(input));
-    };
-    const setUploadProgress = ({ progress, id, }) => {
-        dispatch(setUploadProgressAction$1({ id, progress }));
-    };
-    const setUploadSuccess = ({ id }) => {
-        dispatch(setUploadStatusAction$1({ id, status: FileStatus$1.UPLOADED }));
-    };
-    const setUploadPaused = ({ id }) => {
-        dispatch(setUploadStatusAction$1({ id, status: FileStatus$1.PAUSED }));
-    };
-    const setUploadResumed = ({ id }) => {
-        dispatch(setUploadStatusAction$1({ id, status: FileStatus$1.UPLOADING }));
-    };
-    const removeUpload = ({ id }) => {
-        dispatch(removeUploadAction$1({ id }));
-    };
-    return {
-        removeUpload,
-        setProcessedKey,
-        setUploadPaused,
-        setUploadProgress,
-        setUploadResumed,
-        setUploadSuccess,
-        setUploadingFile,
-        queueFiles,
-        addFiles,
-        clearFiles,
-        files,
-    };
+    const dispatchers = React__default["default"].useMemo(() => ({
+        addFiles: (params) => {
+            dispatch(addFilesAction(params));
+        },
+        clearFiles: () => {
+            dispatch(clearFilesAction());
+        },
+        queueFiles: () => {
+            dispatch(queueFilesAction());
+        },
+        setUploadingFile: (params) => {
+            dispatch(setUploadingFileAction(params));
+        },
+        setUploadProgress: (params) => {
+            dispatch(setUploadProgressAction(params));
+        },
+        setUploadSuccess: (params) => {
+            dispatch(setUploadSuccessAction(params));
+        },
+        setUploadPaused: ({ id }) => {
+            dispatch(setUploadStatusAction({ id, status: FileStatus.PAUSED }));
+        },
+        setUploadResumed: ({ id }) => {
+            dispatch(setUploadStatusAction({ id, status: FileStatus.UPLOADING }));
+        },
+        removeUpload: ({ id }) => {
+            dispatch(removeUploadAction({ id }));
+        },
+    }), []);
+    return { ...dispatchers, files };
 }
 
-const checkMaxFileSize$1 = ({ file, getFileSizeErrorText, maxFileSize, }) => {
+const checkMaxFileSize = ({ file, getFileSizeErrorText, maxFileSize, }) => {
     if (maxFileSize === undefined)
         return '';
     if (file.size > maxFileSize) {
@@ -282,7 +260,7 @@ const defaultFileUploaderDisplayText = {
     },
 };
 
-const filterAllowedFiles$1 = (files, acceptedFileTypes) => {
+const filterAllowedFiles = (files, acceptedFileTypes) => {
     // Allow any files if acceptedFileTypes is undefined, empty array, or contains '*'
     if (!acceptedFileTypes ||
         acceptedFileTypes.length === 0 ||
@@ -313,7 +291,7 @@ const filterAllowedFiles$1 = (files, acceptedFileTypes) => {
  * and returns a Promise that resolves to { file, key, ..rest }
  * regardless if processFile is defined and if it is sync or async
  */
-const resolveFile$1 = ({ processFile, ...input }) => {
+const resolveFile = ({ processFile, ...input }) => {
     return new Promise((resolve, reject) => {
         const result = ui.isFunction(processFile) ? processFile(input) : input;
         if (result instanceof Promise) {
@@ -325,12 +303,12 @@ const resolveFile$1 = ({ processFile, ...input }) => {
     });
 };
 
-const getInput$1 = ({ accessLevel, file, key, onProcessFileSuccess, onProgress, path, processFile, useAccelerateEndpoint, }) => {
+const getInput = ({ accessLevel, file, key, onProgress, path, processFile, useAccelerateEndpoint, }) => {
     return async () => {
         const hasCallbackPath = ui.isTypedFunction(path);
         const hasStringPath = ui.isString(path);
         const hasKeyInput = !!accessLevel && !hasCallbackPath;
-        const { file: data, key: processedKey, ...rest } = await resolveFile$1({ file, key, processFile });
+        const { file: data, key: processedKey, ...rest } = await resolveFile({ file, key, processFile });
         const contentType = file.type || 'binary/octet-stream';
         // IMPORTANT: always pass `...rest` here for backwards compatibility
         const options = { contentType, onProgress, useAccelerateEndpoint, ...rest };
@@ -351,15 +329,11 @@ const getInput$1 = ({ accessLevel, file, key, onProcessFileSuccess, onProgress,
             const resolvedPath = `${hasCallbackPath ? path({ identityId }) : path}${processedKey}`;
             inputResult = { data: file, path: resolvedPath, options };
         }
-        if (processFile) {
-            // provide post-processing value of target `key`
-            onProcessFileSuccess({ processedKey });
-        }
         return inputResult;
     };
 };
 
-async function uploadFile$1({ input, onError, onStart, onComplete, }) {
+async function uploadFile({ input, onError, onStart, onComplete, }) {
     const resolvedInput = await input();
     const uploadTask = storage.uploadData(resolvedInput);
     const key = resolvedInput?.key ??
@@ -381,9 +355,9 @@ async function uploadFile$1({ input, onError, onStart, onComplete, }) {
     return uploadTask;
 }
 
-function useUploadFiles$1({ accessLevel, files, isResumable, maxFileCount, onProcessFileSuccess, onUploadError, onUploadStart, onUploadSuccess, path, processFile, setUploadingFile, setUploadProgress, setUploadSuccess, useAccelerateEndpoint, }) {
+function useUploadFiles({ accessLevel, files, isResumable, maxFileCount, onUploadError, onUploadStart, onUploadSuccess, path, processFile, setUploadingFile, setUploadProgress, setUploadSuccess, useAccelerateEndpoint, }) {
     React__namespace.useEffect(() => {
-        const filesReadyToUpload = files.filter((file) => file.status === FileStatus$1.QUEUED);
+        const filesReadyToUpload = files.filter((file) => file.status === FileStatus.QUEUED);
         if (filesReadyToUpload.length > maxFileCount) {
             return;
         }
@@ -399,27 +373,24 @@ function useUploadFiles$1({ accessLevel, files, isResumable, maxFileCount, onPro
                 setUploadProgress({ id, progress });
             };
             if (file) {
-                const handleProcessFileSuccess = (input) => onProcessFileSuccess({ id, ...input });
-                const input = getInput$1({
+                const input = getInput({
                     accessLevel,
                     file,
                     key,
-                    onProcessFileSuccess: handleProcessFileSuccess,
                     onProgress,
                     path,
                     processFile,
                     useAccelerateEndpoint,
                 });
-                uploadFile$1({
+                uploadFile({
                     input,
                     onComplete: (event) => {
+                        const resolvedKey = event.key ??
+                            event.path;
                         if (ui.isFunction(onUploadSuccess)) {
-                            onUploadSuccess({
-                                key: event.key ??
-                                    event.path,
-                            });
+                            onUploadSuccess({ key: resolvedKey });
                         }
-                        setUploadSuccess({ id });
+                        setUploadSuccess({ id, resolvedKey });
                     },
                     onError: ({ key, error }) => {
                         if (ui.isFunction(onUploadError)) {
@@ -442,7 +413,6 @@ function useUploadFiles$1({ accessLevel, files, isResumable, maxFileCount, onPro
         setUploadProgress,
         setUploadingFile,
         onUploadError,
-        onProcessFileSuccess,
         onUploadSuccess,
         onUploadStart,
         maxFileCount,
@@ -470,16 +440,16 @@ function DropZone$1({ children, displayText, inDropZone, onDragEnter, onDragLeav
 const FileStatusMessage$1 = ({ errorMessage, getPausedText, getUploadingText, percentage, status, uploadSuccessfulText, }) => {
     const icons = internal.useIcons('storageManager');
     switch (status) {
-        case FileStatus$1.UPLOADING: {
+        case FileStatus.UPLOADING: {
             return (React__default["default"].createElement(uiReact.Text, { className: ui.ComponentClassName.FileUploaderFileStatus }, getUploadingText(percentage)));
         }
-        case FileStatus$1.PAUSED:
+        case FileStatus.PAUSED:
             return (React__default["default"].createElement(uiReact.Text, { className: ui.ComponentClassName.FileUploaderFileStatus }, getPausedText(percentage)));
-        case FileStatus$1.UPLOADED:
+        case FileStatus.UPLOADED:
             return (React__default["default"].createElement(uiReact.Text, { className: ui.classNames(ui.ComponentClassName.FileUploaderFileStatus, ui.classNameModifier(ui.ComponentClassName.FileUploaderFileStatus, 'success')) },
                 React__default["default"].createElement(uiReact.View, { as: "span", fontSize: "xl" }, icons?.success ?? React__default["default"].createElement(internal.IconCheck, null)),
                 uploadSuccessfulText));
-        case FileStatus$1.ERROR:
+        case FileStatus.ERROR:
             return (React__default["default"].createElement(uiReact.Text, { className: ui.classNames(ui.ComponentClassName.FileUploaderFileStatus, ui.classNameModifier(ui.ComponentClassName.FileUploaderFileStatus, 'error')) },
                 React__default["default"].createElement(uiReact.View, { as: "span", fontSize: "xl" }, icons?.error ?? React__default["default"].createElement(internal.IconError, null)),
                 errorMessage));
@@ -514,9 +484,9 @@ function FileControl$1({ onPause, onResume, displayName, errorMessage, isImage,
         React__default["default"].createElement(uiReact.View, { className: ui.ComponentClassName.FileUploaderFileWrapper },
             showThumbnails ? (React__default["default"].createElement(FileThumbnail$1, { isImage: isImage, fileName: displayName, url: thumbnailUrl })) : null,
             React__default["default"].createElement(UploadDetails$1, { displayName: displayName, fileSize: size }),
-            status === FileStatus$1.UPLOADING ? (React__default["default"].createElement(uiReact.Loader, { className: ui.ComponentClassName.FileUploaderLoader, variation: "linear", percentage: progress, isDeterminate: loaderIsDeterminate, isPercentageTextHidden: true })) : null,
+            status === FileStatus.UPLOADING ? (React__default["default"].createElement(uiReact.Loader, { className: ui.ComponentClassName.FileUploaderLoader, variation: "linear", percentage: progress, isDeterminate: loaderIsDeterminate, isPercentageTextHidden: true })) : null,
             isResumable &&
-                (status === FileStatus$1.UPLOADING || status === FileStatus$1.PAUSED) ? (status === FileStatus$1.PAUSED ? (React__default["default"].createElement(uiReact.Button, { onClick: onResume, size: "small", variation: "link" }, resumeButtonText)) : (React__default["default"].createElement(uiReact.Button, { onClick: onPause, size: "small", variation: "link" }, pauseButtonText))) : null,
+                (status === FileStatus.UPLOADING || status === FileStatus.PAUSED) ? (status === FileStatus.PAUSED ? (React__default["default"].createElement(uiReact.Button, { onClick: onResume, size: "small", variation: "link" }, resumeButtonText)) : (React__default["default"].createElement(uiReact.Button, { onClick: onPause, size: "small", variation: "link" }, pauseButtonText))) : null,
             React__default["default"].createElement(FileRemoveButton$1, { altText: `Remove file ${displayName}`, onClick: onRemove })),
         React__default["default"].createElement(FileStatusMessage$1, { uploadSuccessfulText: uploadSuccessfulText, getUploadingText: getUploadingText, getPausedText: getPausedText, status: status, errorMessage: errorMessage, percentage: progress })));
 }
@@ -532,10 +502,10 @@ function FileList$1({ displayText, files, hasMaxFilesError, isResumable, onCance
             const { file, status, progress, error, key, isImage, id, uploadTask } = storageFile;
             const thumbnailUrl = file && isImage ? URL.createObjectURL(file) : '';
             const loaderIsDeterminate = isResumable ? progress > 0 : true;
-            const isUploading = status === FileStatus$1.UPLOADING;
+            const isUploading = status === FileStatus.UPLOADING;
             const onRemove = () => {
                 if (isResumable &&
-                    (status === FileStatus$1.UPLOADING || status === FileStatus$1.PAUSED) &&
+                    (status === FileStatus.UPLOADING || status === FileStatus.PAUSED) &&
                     uploadTask) {
                     onCancelUpload({ id, uploadTask });
                 }
@@ -579,7 +549,7 @@ function FilePicker$1({ children, className = ui.ComponentClassName.FileUploader
     return (React__default["default"].createElement(uiReact.Button, { ...props, className: className, size: size }, children));
 }
 
-const VERSION = '3.3.2';
+const VERSION = '3.3.4';
 
 const logger$1 = ui.getLogger('Storage');
 const MISSING_REQUIRED_PROPS_MESSAGE$1 = '`FileUploader` requires a `maxFileCount` prop to be provided.';
@@ -614,13 +584,13 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
     };
     const { getFileSizeErrorText } = displayText;
     const getMaxFileSizeErrorMessage = (file) => {
-        return checkMaxFileSize$1({
+        return checkMaxFileSize({
             file,
             maxFileSize,
             getFileSizeErrorText,
         });
     };
-    const { addFiles, clearFiles, files, removeUpload, queueFiles, setProcessedKey, setUploadingFile, setUploadPaused, setUploadProgress, setUploadSuccess, setUploadResumed, } = useFileUploader(defaultFiles);
+    const { addFiles, clearFiles, files, removeUpload, queueFiles, setUploadingFile, setUploadPaused, setUploadProgress, setUploadSuccess, setUploadResumed, } = useFileUploader(defaultFiles);
     React__namespace.useImperativeHandle(ref, () => ({ clearFiles }));
     const { dragState, ...dropZoneProps } = internal.useDropZone({
         acceptedFileTypes,
@@ -630,15 +600,15 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
             }
             // We need to filter out files by extension here,
             // we don't get filenames on the drag event, only on drop
-            const _acceptedFiles = filterAllowedFiles$1(acceptedFiles, acceptedFileTypes);
+            const _acceptedFiles = filterAllowedFiles(acceptedFiles, acceptedFileTypes);
             addFiles({
                 files: _acceptedFiles,
-                status: autoUpload ? FileStatus$1.QUEUED : FileStatus$1.ADDED,
+                status: autoUpload ? FileStatus.QUEUED : FileStatus.ADDED,
                 getFileErrorMessage: getMaxFileSizeErrorMessage,
             });
         },
     });
-    useUploadFiles$1({
+    useUploadFiles({
         accessLevel,
         files,
         isResumable,
@@ -646,7 +616,6 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
         onUploadError,
         onUploadSuccess,
         onUploadStart,
-        onProcessFileSuccess: setProcessedKey,
         setUploadingFile,
         setUploadProgress,
         setUploadSuccess,
@@ -661,7 +630,7 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
         }
         addFiles({
             files: Array.from(files),
-            status: autoUpload ? FileStatus$1.QUEUED : FileStatus$1.ADDED,
+            status: autoUpload ? FileStatus.QUEUED : FileStatus.ADDED,
             getFileErrorMessage: getMaxFileSizeErrorMessage,
         });
     };
@@ -694,8 +663,7 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
         if (typeof onFileRemove === 'function') {
             const file = files.find((file) => file.id === id);
             if (file) {
-                // return `processedKey` if available and `processFile` is provided
-                const key = (processFile && file?.processedKey) ?? file.key;
+                const key = file.resolvedKey ?? file.key;
                 onFileRemove({ key });
             }
         }
@@ -703,10 +671,10 @@ const FileUploaderBase = React__namespace.forwardRef(function FileUploader({ acc
     // checks if all downloads completed to 100%
     const allUploadsSuccessful = files.length === 0
         ? false
-        : files.every((file) => file?.status === FileStatus$1.UPLOADED);
+        : files.every((file) => file?.status === FileStatus.UPLOADED);
     // Displays if over max files
     const hasMaxFilesError = files.filter((file) => file.progress < 100).length > maxFileCount;
-    const uploadedFilesLength = files.filter((file) => file?.status === FileStatus$1.UPLOADED).length;
+    const uploadedFilesLength = files.filter((file) => file?.status === FileStatus.UPLOADED).length;
     const remainingFilesCount = files.length - uploadedFilesLength;
     // number of files selected for upload when autoUpload is turned off
     const selectedFilesCount = autoUpload ? 0 : remainingFilesCount;
@@ -793,426 +761,6 @@ const StorageImage = ({ accessLevel, className, fallbackSrc, identityId, imgKey,
     return (React__namespace.createElement(uiReact.Image, { ...rest, className: ui.classNames(ui.ComponentClassName.StorageImage, className), src: url?.toString() ?? fallbackSrc }));
 };
 
-var FileStatus;
-(function (FileStatus) {
-    FileStatus["ADDED"] = "added";
-    FileStatus["QUEUED"] = "queued";
-    FileStatus["UPLOADING"] = "uploading";
-    FileStatus["PAUSED"] = "paused";
-    FileStatus["ERROR"] = "error";
-    FileStatus["UPLOADED"] = "uploaded";
-})(FileStatus || (FileStatus = {}));
-
-var StorageManagerActionTypes;
-(function (StorageManagerActionTypes) {
-    StorageManagerActionTypes["ADD_FILES"] = "ADD_FILES";
-    StorageManagerActionTypes["CLEAR_FILES"] = "CLEAR_FILES";
-    StorageManagerActionTypes["QUEUE_FILES"] = "QUEUE_FILES";
-    StorageManagerActionTypes["SET_STATUS"] = "SET_STATUS";
-    StorageManagerActionTypes["SET_PROCESSED_FILE_KEY"] = "SET_PROCESSED_FILE_KEY";
-    StorageManagerActionTypes["SET_STATUS_UPLOADING"] = "SET_STATUS_UPLOADING";
-    StorageManagerActionTypes["SET_UPLOAD_PROGRESS"] = "SET_UPLOAD_PROGRESS";
-    StorageManagerActionTypes["REMOVE_UPLOAD"] = "REMOVE_UPLOAD";
-})(StorageManagerActionTypes || (StorageManagerActionTypes = {}));
-
-const updateFiles = (files, nextFileData) => files.reduce((files, currentFile) => {
-    if (currentFile.id === nextFileData.id) {
-        return [...files, { ...currentFile, ...nextFileData }];
-    }
-    return [...files, currentFile];
-}, []);
-function storageManagerStateReducer(state, action) {
-    switch (action.type) {
-        case StorageManagerActionTypes.ADD_FILES: {
-            const { files, status } = action;
-            const newUploads = files.map((file) => {
-                const errorText = action.getFileErrorMessage(file);
-                return {
-                    // make sure id is unique,
-                    // we only use it internally and don't send it to Storage
-                    id: `${Date.now()}-${file.name}`,
-                    file,
-                    error: errorText,
-                    key: file.name,
-                    status: errorText ? FileStatus.ERROR : status,
-                    isImage: file.type.startsWith('image/'),
-                    progress: -1,
-                };
-            });
-            const newFiles = [...state.files, ...newUploads];
-            return { ...state, files: newFiles };
-        }
-        case StorageManagerActionTypes.CLEAR_FILES: {
-            return { ...state, files: [] };
-        }
-        case StorageManagerActionTypes.QUEUE_FILES: {
-            const { files } = state;
-            const newFiles = files.reduce((files, currentFile) => {
-                return [
-                    ...files,
-                    {
-                        ...currentFile,
-                        ...(currentFile.status === FileStatus.ADDED
-                            ? { status: FileStatus.QUEUED }
-                            : {}),
-                    },
-                ];
-            }, []);
-            return {
-                ...state,
-                files: newFiles,
-            };
-        }
-        case StorageManagerActionTypes.SET_STATUS_UPLOADING: {
-            const { id, uploadTask } = action;
-            const status = FileStatus.UPLOADING;
-            const progress = 0;
-            const nextFileData = { status, progress, id, uploadTask };
-            const files = updateFiles(state.files, nextFileData);
-            return { ...state, files };
-        }
-        case StorageManagerActionTypes.SET_PROCESSED_FILE_KEY: {
-            const { processedKey, id } = action;
-            const files = updateFiles(state.files, { processedKey, id });
-            return { files };
-        }
-        case StorageManagerActionTypes.SET_UPLOAD_PROGRESS: {
-            const { id, progress } = action;
-            const files = updateFiles(state.files, { id, progress });
-            return { ...state, files };
-        }
-        case StorageManagerActionTypes.SET_STATUS: {
-            const { id, status } = action;
-            const files = updateFiles(state.files, { id, status });
-            return { ...state, files };
-        }
-        case StorageManagerActionTypes.REMOVE_UPLOAD: {
-            const { id } = action;
-            const { files } = state;
-            const newFiles = files.reduce((files, currentFile) => {
-                if (currentFile.id === id) {
-                    // remove by not returning currentFile
-                    return [...files];
-                }
-                return [...files, currentFile];
-            }, []);
-            return {
-                ...state,
-                files: newFiles,
-            };
-        }
-    }
-}
-
-const addFilesAction = ({ files, status, getFileErrorMessage, }) => ({
-    type: StorageManagerActionTypes.ADD_FILES,
-    files,
-    status,
-    getFileErrorMessage,
-});
-const clearFilesAction = () => ({
-    type: StorageManagerActionTypes.CLEAR_FILES,
-});
-const queueFilesAction = () => ({
-    type: StorageManagerActionTypes.QUEUE_FILES,
-});
-const setProcessedKeyAction = (input) => ({
-    ...input,
-    type: StorageManagerActionTypes.SET_PROCESSED_FILE_KEY,
-});
-const setUploadingFileAction = ({ id, uploadTask, }) => ({
-    type: StorageManagerActionTypes.SET_STATUS_UPLOADING,
-    id,
-    uploadTask,
-});
-const setUploadProgressAction = ({ id, progress, }) => ({
-    type: StorageManagerActionTypes.SET_UPLOAD_PROGRESS,
-    id,
-    progress,
-});
-const setUploadStatusAction = ({ id, status, }) => ({
-    type: StorageManagerActionTypes.SET_STATUS,
-    id,
-    status,
-});
-const removeUploadAction = ({ id }) => ({
-    type: StorageManagerActionTypes.REMOVE_UPLOAD,
-    id,
-});
-
-const isDefaultFile = (file) => !!(ui.isObject(file) && file.key);
-const createFileFromDefault = (file) => isDefaultFile(file)
-    ? { ...file, id: file.key, status: FileStatus.UPLOADED }
-    : undefined;
-function useStorageManager(defaultFiles = []) {
-    const [{ files }, dispatch] = React__default["default"].useReducer(storageManagerStateReducer, {
-        files: (Array.isArray(defaultFiles)
-            ? defaultFiles.map(createFileFromDefault).filter((file) => !!file)
-            : []),
-    });
-    const addFiles = ({ files, status, getFileErrorMessage, }) => {
-        dispatch(addFilesAction({ files, status, getFileErrorMessage }));
-    };
-    const clearFiles = () => {
-        dispatch(clearFilesAction());
-    };
-    const queueFiles = () => {
-        dispatch(queueFilesAction());
-    };
-    const setUploadingFile = ({ uploadTask, id, }) => {
-        dispatch(setUploadingFileAction({ id, uploadTask }));
-    };
-    const setProcessedKey = (input) => {
-        dispatch(setProcessedKeyAction(input));
-    };
-    const setUploadProgress = ({ progress, id, }) => {
-        dispatch(setUploadProgressAction({ id, progress }));
-    };
-    const setUploadSuccess = ({ id }) => {
-        dispatch(setUploadStatusAction({ id, status: FileStatus.UPLOADED }));
-    };
-    const setUploadPaused = ({ id }) => {
-        dispatch(setUploadStatusAction({ id, status: FileStatus.PAUSED }));
-    };
-    const setUploadResumed = ({ id }) => {
-        dispatch(setUploadStatusAction({ id, status: FileStatus.UPLOADING }));
-    };
-    const removeUpload = ({ id }) => {
-        dispatch(removeUploadAction({ id }));
-    };
-    return {
-        removeUpload,
-        setProcessedKey,
-        setUploadPaused,
-        setUploadProgress,
-        setUploadResumed,
-        setUploadSuccess,
-        setUploadingFile,
-        queueFiles,
-        addFiles,
-        clearFiles,
-        files,
-    };
-}
-
-const checkMaxFileSize = ({ file, getFileSizeErrorText, maxFileSize, }) => {
-    if (maxFileSize === undefined)
-        return '';
-    if (file.size > maxFileSize) {
-        return getFileSizeErrorText(ui.humanFileSize(maxFileSize, true));
-    }
-    return '';
-};
-
-const defaultStorageManagerDisplayText = {
-    getFilesUploadedText(count) {
-        return `${count} ${count === 1 ? 'file uploaded' : 'files uploaded'}`;
-    },
-    getFileSizeErrorText(sizeText) {
-        return `File size must be below ${sizeText}`;
-    },
-    getRemainingFilesText(count) {
-        return `${count} ${count === 1 ? 'file' : 'files'} uploading`;
-    },
-    getSelectedFilesText(count) {
-        return `${count} ${count === 1 ? 'file' : 'files'} selected`;
-    },
-    getUploadingText(percentage) {
-        return `Uploading${percentage > 0 ? `: ${percentage}%` : ''}`;
-    },
-    getUploadButtonText(count) {
-        return `Upload ${count} ${count === 1 ? 'file' : 'files'}`;
-    },
-    getMaxFilesErrorText(count) {
-        return `Cannot choose more than ${count} ${count === 1 ? 'file' : 'files'}. Remove files before updating`;
-    },
-    getErrorText(message) {
-        return message;
-    },
-    doneButtonText: 'Done',
-    clearAllButtonText: 'Clear all',
-    extensionNotAllowedText: 'Extension not allowed',
-    browseFilesText: 'Browse files',
-    dropFilesText: 'Drop files here or',
-    pauseButtonText: 'Pause',
-    resumeButtonText: 'Resume',
-    uploadSuccessfulText: 'Uploaded',
-    getPausedText(percentage) {
-        return `Paused: ${percentage}%`;
-    },
-};
-
-const filterAllowedFiles = (files, acceptedFileTypes) => {
-    // Allow any files if acceptedFileTypes is undefined, empty array, or contains '*'
-    if (!acceptedFileTypes ||
-        acceptedFileTypes.length === 0 ||
-        acceptedFileTypes.includes('*')) {
-        return files;
-    }
-    // Remove any files that are not in the accepted file list
-    return files.filter((file) => {
-        const fileName = file.name || '';
-        const mimeType = (file.type || '').toLowerCase();
-        const baseMimeType = mimeType.replace(/\/.*$/, '');
-        return acceptedFileTypes.some((type) => {
-            const validType = type.trim().toLowerCase();
-            if (validType.charAt(0) === '.') {
-                return fileName.toLowerCase().endsWith(validType);
-            }
-            else if (validType.endsWith('/*')) {
-                // This is something like a image/* mime type
-                return baseMimeType === validType.replace(/\/.*$/, '');
-            }
-            return mimeType === validType;
-        });
-    });
-};
-
-/**
- * Utility function that takes the processFile prop, along with a file a key
- * and returns a Promise that resolves to { file, key, ..rest }
- * regardless if processFile is defined and if it is sync or async
- */
-const resolveFile = ({ processFile, ...input }) => {
-    return new Promise((resolve, reject) => {
-        const result = ui.isFunction(processFile) ? processFile(input) : input;
-        if (result instanceof Promise) {
-            result.then(resolve).catch(reject);
-        }
-        else {
-            resolve(result);
-        }
-    });
-};
-
-const getInput = ({ accessLevel, file, key, onProcessFileSuccess, onProgress, path, processFile, useAccelerateEndpoint, }) => {
-    return async () => {
-        const hasCallbackPath = ui.isTypedFunction(path);
-        const hasStringPath = ui.isString(path);
-        const hasKeyInput = !!accessLevel && !hasCallbackPath;
-        const { file: data, key: processedKey, ...rest } = await resolveFile({ file, key, processFile });
-        const contentType = file.type || 'binary/octet-stream';
-        // IMPORTANT: always pass `...rest` here for backwards compatibility
-        const options = { contentType, onProgress, useAccelerateEndpoint, ...rest };
-        let inputResult;
-        if (hasKeyInput) {
-            // legacy handling of `path` is to prefix to `fileKey`
-            const resolvedKey = hasStringPath
-                ? `${path}${processedKey}`
-                : processedKey;
-            inputResult = {
-                data,
-                key: resolvedKey,
-                options: { ...options, accessLevel },
-            };
-        }
-        else {
-            const { identityId } = await auth.fetchAuthSession();
-            const resolvedPath = `${hasCallbackPath ? path({ identityId }) : path}${processedKey}`;
-            inputResult = { data: file, path: resolvedPath, options };
-        }
-        if (processFile) {
-            // provide post-processing value of target `key`
-            onProcessFileSuccess({ processedKey });
-        }
-        return inputResult;
-    };
-};
-
-async function uploadFile({ input, onError, onStart, onComplete, }) {
-    const resolvedInput = await input();
-    const uploadTask = storage.uploadData(resolvedInput);
-    const key = resolvedInput?.key ??
-        resolvedInput?.path;
-    if (ui.isFunction(onStart)) {
-        onStart({ key, uploadTask });
-    }
-    uploadTask.result
-        .then((result) => {
-        if (ui.isFunction(onComplete) && uploadTask.state === 'SUCCESS') {
-            onComplete(result);
-        }
-    })
-        .catch((error) => {
-        if (ui.isFunction(onError)) {
-            onError({ key, error });
-        }
-    });
-    return uploadTask;
-}
-
-function useUploadFiles({ accessLevel, files, isResumable, maxFileCount, onProcessFileSuccess, onUploadError, onUploadStart, onUploadSuccess, path, processFile, setUploadingFile, setUploadProgress, setUploadSuccess, useAccelerateEndpoint, }) {
-    React__namespace.useEffect(() => {
-        const filesReadyToUpload = files.filter((file) => file.status === FileStatus.QUEUED);
-        if (filesReadyToUpload.length > maxFileCount) {
-            return;
-        }
-        for (const { file, key, id } of filesReadyToUpload) {
-            const onProgress = (event) => {
-                /**
-                 * When a file is zero bytes, the progress.total will equal zero.
-                 * Therefore, this will prevent a divide by zero error.
-                 */
-                const progress = event.totalBytes === undefined || event.totalBytes === 0
-                    ? 100
-                    : Math.floor((event.transferredBytes / event.totalBytes) * 100);
-                setUploadProgress({ id, progress });
-            };
-            if (file) {
-                const handleProcessFileSuccess = (input) => onProcessFileSuccess({ id, ...input });
-                const input = getInput({
-                    accessLevel,
-                    file,
-                    key,
-                    onProcessFileSuccess: handleProcessFileSuccess,
-                    onProgress,
-                    path,
-                    processFile,
-                    useAccelerateEndpoint,
-                });
-                uploadFile({
-                    input,
-                    onComplete: (event) => {
-                        if (ui.isFunction(onUploadSuccess)) {
-                            onUploadSuccess({
-                                key: event.key ??
-                                    event.path,
-                            });
-                        }
-                        setUploadSuccess({ id });
-                    },
-                    onError: ({ key, error }) => {
-                        if (ui.isFunction(onUploadError)) {
-                            onUploadError(error.message, { key });
-                        }
-                    },
-                    onStart: ({ key, uploadTask }) => {
-                        if (ui.isFunction(onUploadStart)) {
-                            onUploadStart({ key });
-                        }
-                        setUploadingFile({ id, uploadTask });
-                    },
-                });
-            }
-        }
-    }, [
-        files,
-        accessLevel,
-        isResumable,
-        setUploadProgress,
-        setUploadingFile,
-        onUploadError,
-        onProcessFileSuccess,
-        onUploadSuccess,
-        onUploadStart,
-        maxFileCount,
-        setUploadSuccess,
-        processFile,
-        path,
-        useAccelerateEndpoint,
-    ]);
-}
-
 function Container({ children, className, }) {
     return React__default["default"].createElement(uiReact.View, { className: className }, children);
 }
@@ -1371,7 +919,7 @@ const StorageManagerBase = React__namespace.forwardRef(function StorageManager({
     const allowMultipleFiles = maxFileCount === undefined ||
         (typeof maxFileCount === 'number' && maxFileCount > 1);
     const displayText = {
-        ...defaultStorageManagerDisplayText,
+        ...defaultFileUploaderDisplayText,
         ...overrideDisplayText,
     };
     const { getFileSizeErrorText } = displayText;
@@ -1382,7 +930,7 @@ const StorageManagerBase = React__namespace.forwardRef(function StorageManager({
             getFileSizeErrorText,
         });
     };
-    const { addFiles, clearFiles, files, removeUpload, queueFiles, setProcessedKey, setUploadingFile, setUploadPaused, setUploadProgress, setUploadSuccess, setUploadResumed, } = useStorageManager(defaultFiles);
+    const { addFiles, clearFiles, files, removeUpload, queueFiles, setUploadingFile, setUploadPaused, setUploadProgress, setUploadSuccess, setUploadResumed, } = useFileUploader(defaultFiles);
     React__namespace.useImperativeHandle(ref, () => ({ clearFiles }));
     const { dragState, ...dropZoneProps } = internal.useDropZone({
         acceptedFileTypes,
@@ -1408,7 +956,6 @@ const StorageManagerBase = React__namespace.forwardRef(function StorageManager({
         onUploadError,
         onUploadSuccess,
         onUploadStart,
-        onProcessFileSuccess: setProcessedKey,
         setUploadingFile,
         setUploadProgress,
         setUploadSuccess,
@@ -1456,8 +1003,7 @@ const StorageManagerBase = React__namespace.forwardRef(function StorageManager({
         if (typeof onFileRemove === 'function') {
             const file = files.find((file) => file.id === id);
             if (file) {
-                // return `processedKey` if available and `processFile` is provided
-                const key = (processFile && file?.processedKey) ?? file.key;
+                const key = file.resolvedKey ?? file.key;
                 onFileRemove({ key });
             }
         }