@aws-amplify/ui-react-storage 3.9.0 → 3.9.2

package/dist/{createAmplifyAuthAdapter-BcuxpEzi.js → createAmplifyAuthAdapter-BJjOYxQA.js}

@@ -32,7 +32,12 @@ function _interopNamespace(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 
-const VERSION = '3.9.0';
+const VERSION = '3.9.2';
+
+const DEFAULT_CHECKSUM_ALGORITHM = 'crc-32';
+// 5MiB for multipart upload
+// https://github.com/aws-amplify/amplify-js/blob/1a5366d113c9af4ce994168653df3aadb142c581/packages/storage/src/providers/s3/utils/constants.ts#L16
+const MULTIPART_UPLOAD_THRESHOLD_BYTES = 5 * 1024 * 1024;
 
 const constructBucket = ({ bucket: bucketName, region, }) => ({ bucketName, region });
 const parseAccessGrantLocation = (location) => {
@@ -118,9 +123,8 @@ const createFileDataItem = (data) => ({
     ...data,
     fileKey: getFileKey(data.key),
 });
-const isFileItem = (value) => !!value.file;
-const isFileDataItem = (item) => !!item.fileKey;
 const getProgress = ({ totalBytes, transferredBytes, }) => totalBytes ? transferredBytes / totalBytes : undefined;
+const isMultipartUpload = (file) => file.size > MULTIPART_UPLOAD_THRESHOLD_BYTES;
 
 const copyHandler = (input) => {
     const { config, data } = input;
@@ -155,12 +159,13 @@ const copyHandler = (input) => {
             status: 'COMPLETE',
             value: { key: path },
         }))
-            .catch(({ message }) => ({ message, status: 'FAILED' })),
+            .catch((error) => {
+            const { message } = error;
+            return { error, message, status: 'FAILED' };
+        }),
     };
 };
 
-const DEFAULT_CHECKSUM_ALGORITHM = 'crc-32';
-
 const createFolderHandler = (input) => {
     const { config, data, options } = input;
     const { accountId, credentials, customEndpoint } = config;
@@ -189,11 +194,12 @@ const createFolderHandler = (input) => {
             status: 'COMPLETE',
             value: { key: path },
         }))
-            .catch(({ message, name }) => {
+            .catch((error) => {
+            const { message, name } = error;
             if (name === 'PreconditionFailed') {
-                return { message, status: 'OVERWRITE_PREVENTED' };
+                return { error, message, status: 'OVERWRITE_PREVENTED' };
             }
-            return { message, status: 'FAILED' };
+            return { error, message, status: 'FAILED' };
         }),
     };
 };
@@ -214,7 +220,10 @@ const deleteHandler = ({ config, data, }) => {
         status: 'COMPLETE',
         value: { key: path },
     }))
-        .catch(({ message }) => ({ message, status: 'FAILED' }));
+        .catch((error) => {
+        const { message } = error;
+        return { error, message, status: 'FAILED' };
+    });
     return { result };
 };
 
@@ -244,11 +253,14 @@ const downloadHandler = ({ config, data: { key }, }) => {
         downloadFromUrl(key, url.toString());
         return { status: 'COMPLETE', value: { url } };
     })
-        .catch(({ message }) => ({ message, status: 'FAILED' }));
+        .catch((error) => {
+        const { message } = error;
+        return { error, message, status: 'FAILED' };
+    });
     return { result };
 };
 
-const DEFAULT_PAGE_SIZE$3 = 1000;
+const DEFAULT_PAGE_SIZE$4 = 1000;
 const parseItems = (items, excludedPath) => items
     // remove root `key` from results
     .filter(({ path }) => path !== excludedPath)
@@ -281,7 +293,7 @@ const parseResult = ({ excludedSubpaths, items }, prefix) => filterDotItems([...
 const listLocationItemsHandler = async (input) => {
     const { config, prefix, options } = input;
     const { bucket: _bucket, credentials, customEndpoint, region, accountId, } = config;
-    const { exclude, delimiter, nextToken, pageSize: _pageSize = DEFAULT_PAGE_SIZE$3, ..._options } = options ?? {};
+    const { exclude, delimiter, nextToken, pageSize: _pageSize = DEFAULT_PAGE_SIZE$4, ..._options } = options ?? {};
     const bucket = { bucketName: _bucket, region };
     const subpathStrategy = {
         delimiter,
@@ -318,39 +330,6 @@ const listLocationItemsHandler = async (input) => {
     return { items: result, nextToken: nextNextToken };
 };
 
-function assertLocationPermissions(value, message) {
-    if (!Array.isArray(value) ||
-        value.some((inputPermissionEntry) => typeof inputPermissionEntry !== 'string' ||
-            !['list', 'get', 'write', 'delete'].includes(inputPermissionEntry))) {
-        throw new Error(message);
-    }
-}
-function assertLocationData(value, message = 'Invalid value provided as `location`.') {
-    const locationStringDataKeys = ['bucket', 'id', 'prefix', 'type'];
-    if (!ui.isObject(value) ||
-        locationStringDataKeys.some((key) => !ui.isString(value[key]))) {
-        throw new Error(message);
-    }
-    assertLocationPermissions(value?.permissions, message);
-}
-function assertPrefix(value, message) {
-    if (!ui.isString(value)) {
-        throw new Error(message ?? 'Invalid value provided as `prefix`.');
-    }
-}
-
-function assertRegisterAuthListener(value) {
-    if (!ui.isFunction(value)) {
-        throw new Error('StorageBrowser: `registerAuthListener` must be a function.');
-    }
-}
-
-const UPLOAD_FILE_SIZE_LIMIT = 160 * 1000 * 1000 * 1000;
-const isFileTooBig = (file) => file.size > UPLOAD_FILE_SIZE_LIMIT;
-
-// 5MB for multipart upload
-// https://github.com/aws-amplify/amplify-js/blob/1a5366d113c9af4ce994168653df3aadb142c581/packages/storage/src/providers/s3/utils/constants.ts#L16
-const MULTIPART_UPLOAD_THRESHOLD_BYTES = 5 * 1024 * 1024;
 const UNDEFINED_CALLBACKS = {
     cancel: undefined,
     pause: undefined,
@@ -378,7 +357,7 @@ const uploadHandler = ({ config, data, options }) => {
     };
     const { cancel, pause, resume, result } = internals.uploadData(input);
     return {
-        ...(file.size > MULTIPART_UPLOAD_THRESHOLD_BYTES
+        ...(isMultipartUpload(file)
             ? { cancel, pause, resume }
             : UNDEFINED_CALLBACKS),
         result: result
@@ -389,16 +368,53 @@ const uploadHandler = ({ config, data, options }) => {
             .catch((error) => {
             const { message } = error;
             if (error.name === 'PreconditionFailed') {
-                return { message, status: 'OVERWRITE_PREVENTED' };
+                return { error, message, status: 'OVERWRITE_PREVENTED' };
             }
-            return {
-                message,
-                status: storage.isCancelError(error) ? 'CANCELED' : 'FAILED',
-            };
+            const status = storage.isCancelError(error) ? 'CANCELED' : 'FAILED';
+            return { error, message, status };
         }),
     };
 };
 
+const defaultHandlers = {
+    copy: copyHandler,
+    createFolder: createFolderHandler,
+    delete: deleteHandler,
+    download: downloadHandler,
+    listLocationItems: listLocationItemsHandler,
+    upload: uploadHandler,
+};
+
+function assertLocationPermissions(value, message) {
+    if (!Array.isArray(value) ||
+        value.some((inputPermissionEntry) => typeof inputPermissionEntry !== 'string' ||
+            !['list', 'get', 'write', 'delete'].includes(inputPermissionEntry))) {
+        throw new Error(message);
+    }
+}
+function assertLocationData(value, message = 'Invalid value provided as `location`.') {
+    const locationStringDataKeys = ['bucket', 'id', 'prefix', 'type'];
+    if (!ui.isObject(value) ||
+        locationStringDataKeys.some((key) => !ui.isString(value[key]))) {
+        throw new Error(message);
+    }
+    assertLocationPermissions(value?.permissions, message);
+}
+function assertPrefix(value, message) {
+    if (!ui.isString(value)) {
+        throw new Error(message ?? 'Invalid value provided as `prefix`.');
+    }
+}
+
+function assertRegisterAuthListener(value) {
+    if (!ui.isFunction(value)) {
+        throw new Error('StorageBrowser: `registerAuthListener` must be a function.');
+    }
+}
+
+const UPLOAD_FILE_SIZE_LIMIT = 160 * 1000 * 1000 * 1000;
+const isFileTooBig = (file) => file.size > UPLOAD_FILE_SIZE_LIMIT;
+
 const defaultValue$9 = {
     actionConfigs: undefined,
 };
@@ -412,7 +428,7 @@ const copyActionConfig = {
         icon: 'copy-file',
         label: 'Copy',
     },
-    handler: copyHandler,
+    handler: defaultHandlers.copy,
 };
 const deleteActionConfig = {
     viewName: 'DeleteView',
@@ -422,7 +438,7 @@ const deleteActionConfig = {
         icon: 'delete-file',
         label: 'Delete',
     },
-    handler: deleteHandler,
+    handler: defaultHandlers.delete,
 };
 const createFolderActionConfig = {
     viewName: 'CreateFolderView',
@@ -431,7 +447,7 @@ const createFolderActionConfig = {
         icon: 'create-folder',
         label: 'Create folder',
     },
-    handler: createFolderHandler,
+    handler: defaultHandlers.createFolder,
 };
 const uploadActionConfig = {
     viewName: 'UploadView',
@@ -440,12 +456,14 @@ const uploadActionConfig = {
         icon: 'upload-file',
         label: 'Upload',
     },
-    handler: uploadHandler,
+    handler: defaultHandlers.upload,
 };
+// Action view configs only, does not include `listLocationItems`
 const defaultActionViewConfigs = {
     copy: copyActionConfig,
     createFolder: createFolderActionConfig,
-    download: downloadHandler,
+    // provide `download` handler only; `download` does not have a dedicated view/config
+    download: defaultHandlers.download,
     delete: deleteActionConfig,
     upload: uploadActionConfig,
 };
@@ -453,7 +471,7 @@ const DEFAULT_ACTION_VIEW_TYPES = Object.keys(defaultActionViewConfigs);
 const isDefaultActionViewType = (value) => DEFAULT_ACTION_VIEW_TYPES.some((type) => type === value);
 const defaultActionConfigs = {
     ...defaultActionViewConfigs,
-    listLocationItems: listLocationItemsHandler,
+    listLocationItems: defaultHandlers.listLocationItems,
 };
 
 const isActionConfig = (value) => ui.isObject(value);
@@ -1084,7 +1102,7 @@ const OverwriteToggle = ({ isDisabled, isOverwritingEnabled, label = '', onToggl
             onToggle?.();
         } }));
 };
-const SearchSubfoldersToggle = ({ isSearchingSubfolders, label = '', onToggle, }) => {
+const SearchSubfoldersToggle = ({ isSearchingSubfolders, label = '', onToggle }) => {
     return (React__namespace.createElement(uiReact.CheckboxField, { name: label, label: label, labelPosition: "end", checked: isSearchingSubfolders, onChange: () => {
             onToggle?.();
         } }));
@@ -1114,7 +1132,7 @@ const Navigation = ({ items }) => {
             item.isCurrent ? null : React__namespace.createElement(uiReact.Breadcrumbs.Separator, null)));
     })));
 };
-const LoadingIndicator = ({ isLoading }) => {
+const LoadingIndicator = ({ isLoading, }) => {
     if (isLoading) {
         return (React__namespace.createElement(uiReact.Loader, { className: "amplify-storage-browser__loader", variation: "linear", size: "small" }));
     }
@@ -1129,7 +1147,7 @@ const FolderNameField = ({ onChange, label, placeholder, validationMessage, onVa
             onChange?.(value);
         } }));
 };
-const DataRefresh = ({ onRefresh }) => {
+const DataRefresh = ({ onRefresh, }) => {
     return (React__namespace.createElement(uiReact.Button, { onClick: () => {
             onRefresh?.();
         }, "aria-label": "Refresh data" },
@@ -1147,7 +1165,7 @@ const ActionsList = ({ items, onActionSelect, isDisabled, }) => {
             label));
     })));
 };
-const StatusDisplay = ({ statuses, total }) => {
+const StatusDisplay = ({ statuses, total, }) => {
     if (!statuses?.length) {
         return null;
     }
@@ -1203,7 +1221,6 @@ const DEFAULT_ACTION_VIEW_DISPLAY_TEXT = {
     tableColumnNameHeader: 'Name',
     tableColumnTypeHeader: 'Type',
     tableColumnSizeHeader: 'Size',
-    tableColumnProgressHeader: 'Progress',
 };
 const DEFAULT_LIST_VIEW_DISPLAY_TEXT = {
     loadingIndicatorLabel: 'Loading',
@@ -1433,7 +1450,6 @@ const DEFAULT_LOCATIONS_VIEW_DISPLAY_TEXT = {
 
 const DEFAULT_UPLOAD_VIEW_DISPLAY_TEXT = {
     ...DEFAULT_ACTION_VIEW_DISPLAY_TEXT,
-    title: 'Upload',
     actionStartLabel: 'Upload',
     addFilesLabel: 'Add files',
     addFolderLabel: 'Add folder',
@@ -1509,8 +1525,10 @@ const DEFAULT_UPLOAD_VIEW_DISPLAY_TEXT = {
         }
         return undefined;
     },
-    statusDisplayOverwritePreventedLabel: 'Overwrite prevented',
     overwriteToggleLabel: 'Overwrite existing files',
+    statusDisplayOverwritePreventedLabel: 'Overwrite prevented',
+    tableColumnProgressHeader: 'Progress',
+    title: 'Upload',
 };
 
 const DEFAULT_STORAGE_BROWSER_DISPLAY_TEXT = {
@@ -1561,6 +1579,9 @@ function DisplayTextProvider({ children, displayText: _override, }) {
     return (React__namespace["default"].createElement(DisplayTextContext.Provider, { value: resolvedDisplayText }, children));
 }
 
+const isCopyViewDisplayTextKey = (value) => !!DEFAULT_COPY_VIEW_DISPLAY_TEXT[value];
+const isDeleteViewDisplayTextKey = (value) => !!DEFAULT_DELETE_VIEW_DISPLAY_TEXT[value];
+
 const Fallback = () => (React__namespace["default"].createElement("div", { className: STORAGE_BROWSER_BLOCK_TO_BE_UPDATED },
     React__namespace["default"].createElement("div", { className: `${STORAGE_BROWSER_BLOCK_TO_BE_UPDATED}__error-boundary` }, "Something went wrong.")));
 class ErrorBoundary extends React__namespace["default"].Component {
@@ -2464,207 +2485,342 @@ const TitleControl = () => {
     return React__namespace["default"].createElement(Resolved, { ...props });
 };
 
-const getActionIcon = (status) => {
-    switch (status) {
-        case 'PENDING': {
-            return 'action-progress';
-        }
-        case 'COMPLETE': {
-            return 'action-success';
-        }
-        case 'FAILED': {
-            return 'action-error';
-        }
-        case 'OVERWRITE_PREVENTED': {
-            return 'action-info';
-        }
-        case 'CANCELED': {
-            return 'action-canceled';
-        }
-        case 'QUEUED':
-        default: {
-            return 'action-queued';
-        }
-    }
-};
-
-const getFileTypeDisplayValue = (fileName) => fileName.lastIndexOf('.') !== -1
-    ? fileName.slice(fileName.lastIndexOf('.') + 1)
-    : '';
+function useResolveDataTable(keys, { getCell, getHeader, getRowKey }, { items, props }) {
+    return React__namespace["default"].useMemo(() => {
+        const getRow = (item) => ({
+            key: getRowKey({ item, props }),
+            content: keys.map((key) => getCell({ key, item, props })),
+        });
+        const headers = keys.map((key) => getHeader({ key, props }));
+        const rows = (items ?? []).map(getRow);
+        return { headers, rows };
+    }, [getCell, getHeader, getRowKey, keys, items, props]);
+}
 
-const getPercentValue = (value) => Math.round(value * 100);
+const STATUS_LABELS = {
+    PENDING: 'statusDisplayInProgressLabel',
+    CANCELED: 'statusDisplayCanceledLabel',
+    COMPLETE: 'statusDisplayCompletedLabel',
+    FAILED: 'statusDisplayFailedLabel',
+    QUEUED: 'statusDisplayQueuedLabel',
+    OVERWRITE_PREVENTED: 'statusDisplayOverwritePreventedLabel',
+};
+const STATUS_ICONS = {
+    PENDING: 'action-progress',
+    COMPLETE: 'action-success',
+    FAILED: 'action-error',
+    OVERWRITE_PREVENTED: 'action-info',
+    CANCELED: 'action-canceled',
+    QUEUED: 'action-queued',
+};
+
+const getFileType = (value, fallback = '') => value.lastIndexOf('.') !== -1
+    ? value.slice(value.lastIndexOf('.') + 1)
+    : fallback;
+const getCellName = (value) => 
+// `value.split` always returns an array with at least one entry
+// ensruing `.pop()` will always return a string
+value.split('/').pop();
+const getUploadCellFolder = ({ data: { file: { webkitRelativePath }, }, }, fallback = '-') => webkitRelativePath
+    ? webkitRelativePath.slice(0, webkitRelativePath.lastIndexOf('/') + 1)
+    : fallback;
+const getCopyCellFolder = ({ data: { fileKey, sourceKey }, }) => sourceKey.slice(0, -fileKey.length);
+const getDeleteCellFolder = ({ data: { fileKey, key }, }) => key.slice(0, -fileKey.length);
+const getUploadCellProgress = ({ progress, status, }) => {
+    // prefer `progress` if available, 1 if status is complete, default 0
+    const value = progress ?? (status === 'COMPLETE' ? 1 : 0);
+    const displayValue = `${Math.round(value * 100)}%`;
+    return { displayValue, value };
+};
+const getFileSize = (value, fallback = '-') => (!value ? fallback : ui.humanFileSize(value, true));
+const getCopyOrDeleteCancelCellContent = (data) => {
+    const { item, props } = data;
+    const { cancel, status } = item;
+    const { isProcessing, onTaskRemove } = props;
+    const isQueued = status === 'QUEUED';
+    // a task is removable prior to processing start. Including `isQueued` ensures
+    // that `isRemovable` is `false` on all tasks processing complete
+    const isRemovable = isQueued && !isProcessing;
+    // a task is cancelable while processing is true, and the task has a cancel handler
+    const isCancelable = isProcessing && !!cancel;
+    const ariaLabel = `${isRemovable ? 'Remove' : 'Cancel'} item: ${getCellName(item.data.fileKey)}`;
+    const isDisabled = !isRemovable && !isCancelable;
+    // resolve to `undefined` if not cancelable or removable
+    const onClick = !isCancelable && !isRemovable
+        ? undefined
+        : () => {
+            if (isRemovable) {
+                onTaskRemove?.(item);
+                // do not run cancel handler on remove
+                return;
+            }
+            if (isCancelable)
+                cancel();
+        };
+    return { ariaLabel, isDisabled, onClick, icon: 'cancel' };
+};
 
-const getDefaultActionViewHeaders = ({ displayText: { tableColumnNameHeader, tableColumnTypeHeader, tableColumnSizeHeader, tableColumnStatusHeader, tableColumnCancelHeader, tableColumnFolderHeader, }, }) => {
-    return [
-        {
-            key: 'name',
-            type: 'sort',
-            content: { label: tableColumnNameHeader },
-        },
-        {
-            key: 'folder',
-            type: 'sort',
-            content: { label: tableColumnFolderHeader },
-        },
-        { key: 'type', type: 'sort', content: { label: tableColumnTypeHeader } },
-        { key: 'size', type: 'sort', content: { label: tableColumnSizeHeader } },
-        {
-            key: 'status',
-            type: 'sort',
-            content: { label: tableColumnStatusHeader },
-        },
-        { key: 'cancel', type: 'text', content: { text: tableColumnCancelHeader } },
-    ];
+const COPY_TABLE_KEYS = [
+    'name',
+    'folder',
+    'type',
+    'size',
+    'status',
+    'cancel',
+];
+const getCopyCellKey = ({ key, item, }) => `${key}-${item.data.id}`;
+const name$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const { item } = data;
+    const text = item.data.fileKey;
+    const icon = STATUS_ICONS[item.status];
+    return { key, type: 'text', content: { icon, text } };
+};
+const folder$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const text = getCopyCellFolder(data.item);
+    return { key, type: 'text', content: { text } };
+};
+const type$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const { fileKey } = data.item.data;
+    const text = getFileType(fileKey);
+    return { key, type: 'text', content: { text } };
+};
+const size$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const { size: value } = data.item.data;
+    const displayValue = getFileSize(value);
+    return { key, type: 'number', content: { value, displayValue } };
+};
+const status$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const { item: { status }, props: { displayText }, } = data;
+    const statusLabelKey = STATUS_LABELS[status];
+    const text = isCopyViewDisplayTextKey(statusLabelKey)
+        ? displayText[statusLabelKey]
+        : '';
+    return { key, type: 'text', content: { text } };
+};
+const cancel$2 = (data) => {
+    const key = getCopyCellKey(data);
+    const content = getCopyOrDeleteCancelCellContent(data);
+    return { key, type: 'button', content };
+};
+const COPY_CELL_RESOLVERS = {
+    name: name$2,
+    folder: folder$2,
+    type: type$2,
+    size: size$2,
+    status: status$2,
+    cancel: cancel$2,
+    /**
+     * @deprecated
+     *
+     * non-upload view tables do not include "progress" headers but include here to
+     * keep TS happy as "progress" headers were included in display text interfaces
+     * and cannot be removed from the tables without a breaking change
+     */
+    progress: ui.noop,
+};
+const COPY_TABLE_RESOLVERS = {
+    getCell: (data) => COPY_CELL_RESOLVERS[data.key](data),
+    getHeader: ({ key, props: { displayText } }) => {
+        const text = displayText[`tableColumn${ui.capitalize(key)}Header`];
+        if (key === 'cancel') {
+            return { key, type: 'text', content: { text } };
+        }
+        return { key, type: 'sort', content: { label: text } };
+    },
+    getRowKey: ({ item }) => item.data.id,
 };
 
-const getTaskStatusDisplayLabel = ({ status, displayText: { statusDisplayInProgressLabel, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, statusDisplayOverwritePreventedLabel, }, }) => {
-    switch (status) {
-        case 'PENDING':
-            return statusDisplayInProgressLabel;
-        case 'CANCELED':
-            return statusDisplayCanceledLabel;
-        case 'COMPLETE':
-            return statusDisplayCompletedLabel;
-        case 'FAILED':
-            return statusDisplayFailedLabel;
-        case 'QUEUED':
-            return statusDisplayQueuedLabel;
-        case 'OVERWRITE_PREVENTED':
-            return statusDisplayOverwritePreventedLabel;
-        default:
-            return statusDisplayQueuedLabel;
+const UPLOAD_TABLE_KEYS = [
+    'name',
+    'folder',
+    'type',
+    'size',
+    'status',
+    'progress',
+    'cancel',
+];
+const getUploadCellKey = ({ key, item, }) => `${key}-${item.data.id}`;
+const name$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const { item } = data;
+    const icon = STATUS_ICONS[item.status];
+    const text = getCellName(item.data.key);
+    return { key, type: 'text', content: { icon, text } };
+};
+const folder$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const text = getUploadCellFolder(data.item);
+    return { key, type: 'text', content: { text } };
+};
+const type$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const { item } = data;
+    const text = getFileType(getCellName(item.data.key));
+    return { key, type: 'text', content: { text } };
+};
+const size$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const { size: value } = data.item.data.file;
+    const displayValue = getFileSize(value);
+    return { key, type: 'number', content: { value, displayValue } };
+};
+const status$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const { item: { status }, props: { displayText }, } = data;
+    const text = displayText[STATUS_LABELS[status]];
+    return { key, type: 'text', content: { text } };
+};
+const progress = (data) => {
+    const key = getUploadCellKey(data);
+    const content = getUploadCellProgress(data.item);
+    return { key, type: 'number', content };
+};
+const cancel$1 = (data) => {
+    const key = getUploadCellKey(data);
+    const { item, props } = data;
+    const { cancel, data: taskData, status, progress } = item;
+    const { isMultipartUpload, isProcessing, onTaskRemove } = props;
+    const isQueued = status === 'QUEUED';
+    const isPending = status === 'PENDING';
+    // cancelability is dependent on differing conditions for multipart and single part uploads
+    let isCancelable;
+    if (isMultipartUpload(taskData.file)) {
+        // signals MPU complete has been reached
+        const hasUploadedAllBytes = progress === 1;
+        // MPU allows cancel when tasks processing has begun and task is queued or
+        // pending but not yet reached MPU complete
+        isCancelable =
+            isProcessing && (isQueued || isPending) && !hasUploadedAllBytes;
     }
-};
-const getProgressHeader = (label) => ({
-    key: 'progress',
-    type: 'sort',
-    content: { label },
-});
-const getActionViewTableData = ({ tasks, displayText, isProcessing, locationKey, shouldDisplayProgress = false, onTaskRemove, }) => {
-    const headers = [
-        ...getDefaultActionViewHeaders({
-            displayText,
-        }),
-    ];
-    if (shouldDisplayProgress) {
-        headers.splice(-1, 0, getProgressHeader(displayText.tableColumnProgressHeader));
+    else {
+        // single part upload allows cancel when processing has begun and task is queued
+        isCancelable = isProcessing && isQueued;
     }
-    const rows = tasks.map((task) => {
-        const { cancel, data, progress, status } = task;
-        const { id } = data;
-        const displayKey = isFileDataItem(data)
-            ? data.fileKey
-            : data.key.split('/').pop() ?? '';
-        return {
-            key: id,
-            content: headers.map(({ key: columnKey }) => {
-                const key = `${columnKey}-${id}`;
-                switch (columnKey) {
-                    case 'name': {
-                        return {
-                            key,
-                            type: 'text',
-                            content: {
-                                icon: getActionIcon(status),
-                                text: displayKey,
-                            },
-                        };
-                    }
-                    case 'folder': {
-                        if (locationKey) {
-                            return { key, type: 'text', content: { text: locationKey } };
-                        }
-                        if (isFileItem(data)) {
-                            const { webkitRelativePath } = data.file;
-                            return {
-                                key,
-                                type: 'text',
-                                content: {
-                                    text: webkitRelativePath
-                                        ? webkitRelativePath.slice(0, webkitRelativePath.lastIndexOf('/') + 1)
-                                        : '-',
-                                },
-                            };
-                        }
-                        return { key, type: 'text', content: { text: '/' } };
-                    }
-                    case 'type': {
-                        return {
-                            key,
-                            type: 'text',
-                            content: { text: getFileTypeDisplayValue(displayKey) },
-                        };
-                    }
-                    case 'size': {
-                        const value = isFileItem(data)
-                            ? data.file.size
-                            : isFileDataItem(data)
-                                ? data.size
-                                : undefined;
-                        return {
-                            key,
-                            type: 'number',
-                            content: {
-                                value,
-                                displayValue: value ? ui.humanFileSize(value, true) : '-',
-                            },
-                        };
-                    }
-                    case 'status': {
-                        return {
-                            key,
-                            type: 'text',
-                            content: {
-                                text: getTaskStatusDisplayLabel({ status, displayText }),
-                            },
-                        };
-                    }
-                    case 'progress': {
-                        return {
-                            key,
-                            type: 'number',
-                            content: {
-                                value: progress,
-                                displayValue: `${getPercentValue(
-                                // Default progress to 100% if progress value is unavailable but status is recognized as complete
-                                progress ?? (status === 'COMPLETE' ? 1 : 0))}%`,
-                            },
-                        };
-                    }
-                    case 'cancel': {
-                        const isPending = status === 'PENDING';
-                        const isQueued = status === 'QUEUED';
-                        const isDisabled = (!isPending && !isQueued) || !cancel || progress === 1;
-                        const ariaLabel = `${isProcessing ? 'Cancel' : 'Remove'} item: ${displayKey}`;
-                        return {
-                            key,
-                            type: 'button',
-                            content: {
-                                isDisabled,
-                                onClick: () => {
-                                    if (!isProcessing) {
-                                        onTaskRemove?.(task);
-                                    }
-                                    cancel?.();
-                                },
-                                ariaLabel,
-                                icon: 'cancel',
-                            },
-                        };
-                    }
-                    default:
-                        return { key, type: 'text', content: {} };
-                }
-            }),
+    // all uploads are removable prior to processing start. Including `isQueued`
+    // ensures that `isRemovable` is `false` on all tasks processing complete
+    const isRemovable = !isProcessing && isQueued;
+    const isDisabled = !isRemovable && !isCancelable;
+    const ariaLabel = `${isRemovable ? 'Remove' : 'Cancel'} item: ${getCellName(item.data.key)}`;
+    // resolve to `undefined` if not cancelable or removable
+    const onClick = !isCancelable && !isRemovable
+        ? undefined
+        : () => {
+            if (isRemovable) {
+                onTaskRemove?.(item);
+                // do not run cancel handler on remove
+                return;
+            }
+            if (!!cancel && isCancelable)
+                cancel();
         };
-    });
-    return { headers, rows };
+    const content = { ariaLabel, isDisabled, onClick, icon: 'cancel' };
+    return { key, type: 'button', content };
+};
+const UPLOAD_CELL_RESOLVERS = {
+    cancel: cancel$1,
+    folder: folder$1,
+    name: name$1,
+    progress,
+    size: size$1,
+    status: status$1,
+    type: type$1,
+};
+const UPLOAD_TABLE_RESOLVERS = {
+    getCell: (data) => UPLOAD_CELL_RESOLVERS[data.key](data),
+    getHeader: ({ key, props: { displayText } }) => {
+        const text = displayText[`tableColumn${ui.capitalize(key)}Header`];
+        if (key === 'cancel') {
+            return { key, type: 'text', content: { text } };
+        }
+        return { key, type: 'sort', content: { label: text } };
+    },
+    getRowKey: ({ item }) => item.data.id,
+};
+
+const DELETE_TABLE_KEYS = [
+    'name',
+    'folder',
+    'type',
+    'size',
+    'status',
+    'cancel',
+];
+const getDeleteCellKey = ({ key, item, }) => `${key}-${item.data.id}`;
+const name = (data) => {
+    const key = getDeleteCellKey(data);
+    const { item } = data;
+    const text = item.data.fileKey;
+    const icon = STATUS_ICONS[item.status];
+    return { key, type: 'text', content: { icon, text } };
+};
+const folder = (data) => {
+    const key = getDeleteCellKey(data);
+    const text = getDeleteCellFolder(data.item);
+    return { key, type: 'text', content: { text } };
+};
+const type = (data) => {
+    const key = getDeleteCellKey(data);
+    const { fileKey } = data.item.data;
+    const text = getFileType(fileKey);
+    return { key, type: 'text', content: { text } };
+};
+const size = (data) => {
+    const key = getDeleteCellKey(data);
+    const { size: value } = data.item.data;
+    const displayValue = getFileSize(value);
+    return { key, type: 'number', content: { value, displayValue } };
+};
+const status = (data) => {
+    const key = getDeleteCellKey(data);
+    const { item: { status }, props: { displayText }, } = data;
+    const statusLabelKey = STATUS_LABELS[status];
+    const text = isDeleteViewDisplayTextKey(statusLabelKey)
+        ? displayText[statusLabelKey]
+        : '';
+    return { key, type: 'text', content: { text } };
+};
+const cancel = (data) => {
+    const key = getDeleteCellKey(data);
+    const content = getCopyOrDeleteCancelCellContent(data);
+    return { key, type: 'button', content };
+};
+const DELETE_CELL_RESOLVERS = {
+    name,
+    folder,
+    type,
+    size,
+    status,
+    cancel,
+    /**
+     * @deprecated
+     *
+     * non-upload view tables do not include "progress" headers but include here to
+     * keep TS happy as "progress" headers were included in display text interfaces
+     * and cannot be removed from the tables without a breaking change
+     */
+    progress: ui.noop,
+};
+const DELETE_TABLE_RESOLVERS = {
+    getCell: (data) => DELETE_CELL_RESOLVERS[data.key](data),
+    getHeader: ({ key, props: { displayText } }) => {
+        const text = displayText[`tableColumn${ui.capitalize(key)}Header`];
+        if (key === 'cancel') {
+            return { key, type: 'text', content: { text } };
+        }
+        return { key, type: 'sort', content: { label: text } };
+    },
+    getRowKey: ({ item }) => item.data.id,
 };
 
 function UploadViewProvider({ children, ...props }) {
     const { UploadView: displayText } = useDisplayText();
     const { actionCancelLabel, actionDestinationLabel, actionExitLabel, actionStartLabel, addFilesLabel, addFolderLabel, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, overwriteToggleLabel, title, getActionCompleteMessage, getFilesValidationMessage, } = displayText;
-    const { isOverwritingEnabled, isProcessing, isProcessingComplete, location, tasks, statusCounts, invalidFiles, onActionStart, onActionCancel, onDropFiles, onActionExit, onTaskRemove, onSelectFiles, onToggleOverwrite, } = props;
+    const { isOverwritingEnabled, isProcessing, isProcessingComplete, location, tasks: items, statusCounts, invalidFiles, onActionStart, onActionCancel, onDropFiles, onActionExit, onTaskRemove, onSelectFiles, onToggleOverwrite, } = props;
     const isActionStartDisabled = isProcessing || isProcessingComplete || statusCounts.TOTAL === 0;
     const isActionCancelDisabled = !isProcessing || isProcessingComplete;
     const isAddFilesDisabled = isProcessing || isProcessingComplete;
@@ -2678,6 +2834,10 @@ function UploadViewProvider({ children, ...props }) {
     const filesValidationMessage = invalidFiles && !isProcessing
         ? getFilesValidationMessage({ invalidFiles })
         : undefined;
+    const tableData = useResolveDataTable(UPLOAD_TABLE_KEYS, UPLOAD_TABLE_RESOLVERS, {
+        items,
+        props: { displayText, isProcessing, isMultipartUpload, onTaskRemove },
+    });
     return (React__namespace["default"].createElement(ControlsContextProvider, { data: {
             actionCancelLabel,
             actionDestinationLabel,
@@ -2701,13 +2861,7 @@ function UploadViewProvider({ children, ...props }) {
             statusDisplayCompletedLabel,
             statusDisplayFailedLabel,
             statusDisplayQueuedLabel,
-            tableData: getActionViewTableData({
-                tasks,
-                shouldDisplayProgress: true,
-                displayText,
-                isProcessing,
-                onTaskRemove,
-            }),
+            tableData,
             title,
         }, onActionCancel: onActionCancel, onActionExit: onActionExit, onActionStart: onActionStart, onAddFiles: () => {
             onSelectFiles('FILE');
@@ -2843,6 +2997,9 @@ const createEnhancedListHandler = (action) => {
     };
 };
 
+const DEFAULT_ACTION_CONCURRENCY = 4;
+const USE_LIST_ERROR_MESSAGE = '`useList` must be called from within `StorageBrowser.Provider`';
+
 const INITIAL_STATUS_COUNTS = {
     CANCELED: 0,
     COMPLETE: 0,
@@ -2873,8 +3030,8 @@ const QUEUED_TASK_BASE = {
     status: 'QUEUED',
 };
 const isTaskHandlerInput = (input) => !!input.data;
-const useProcessTasks = (handler, items, options) => {
-    const { concurrency, ...callbacks } = options ?? {};
+function useProcessTasks(handler, options) {
+    const { concurrency, items, ...callbacks } = options ?? {};
     const callbacksRef = React__namespace["default"].useRef(callbacks);
     if (callbacks) {
         callbacksRef.current = callbacks;
@@ -2900,6 +3057,7 @@ const useProcessTasks = (handler, items, options) => {
             tasksRef.current.set(id, { ...task, ...next });
         }
         flush();
+        return !next ? undefined : tasksRef.current.get(id);
     }, [flush]);
     const createTask = React__namespace["default"].useCallback((data) => {
         const getTask = () => tasksRef.current.get(data.id);
@@ -2908,9 +3066,12 @@ const useProcessTasks = (handler, items, options) => {
             const task = getTask();
             if (!task || task?.status !== 'QUEUED')
                 return;
-            if (task && ui.isFunction(onTaskCancel))
-                onTaskCancel(task);
-            updateTask(data.id, { cancel: undefined, status: 'CANCELED' });
+            const canceledTask = updateTask(data.id, {
+                cancel: undefined,
+                status: 'CANCELED',
+            });
+            if (canceledTask && ui.isFunction(onTaskCancel))
+                onTaskCancel(canceledTask);
         }
         const task = { ...QUEUED_TASK_BASE, cancel, data };
         tasksRef.current.set(data.id, task);
@@ -2955,16 +3116,15 @@ const useProcessTasks = (handler, items, options) => {
         const { onTaskCancel, onTaskComplete, onTaskError, onTaskProgress, onTaskSuccess, } = callbacksRef.current;
         const getTask = () => tasksRef.current.get(data.id);
         const { options } = _input;
-        const { onProgress: _onProgress, onSuccess, onError } = options ?? {};
+        const { onProgress: _onProgress } = options ?? {};
         const onProgress = ({ id }, progress) => {
-            const task = getTask();
+            const task = updateTask(id, { progress });
             if (task && ui.isFunction(onTaskProgress)) {
                 onTaskProgress(task, progress);
             }
             if (task && ui.isFunction(_onProgress)) {
                 _onProgress(data, progress);
             }
-            updateTask(id, { progress });
         };
         const input = { ..._input, data, options: { ...options, onProgress } };
         const { cancel: _cancel, result } = handler(input);
@@ -2978,21 +3138,16 @@ const useProcessTasks = (handler, items, options) => {
             };
         result
             .then((output) => {
-            const task = getTask();
-            if (task && ui.isFunction(onTaskSuccess)) {
-                onTaskSuccess(task, output?.value);
-            }
-            if (task && ui.isFunction(onSuccess))
-                onSuccess(data, output?.value);
-            updateTask(data.id, output);
+            const task = updateTask(data.id, output);
+            const { value } = output;
+            if (task && ui.isFunction(onTaskSuccess))
+                onTaskSuccess(task, value);
         })
-            .catch((e) => {
-            const task = getTask();
+            .catch((error) => {
+            const { message } = error;
+            const task = updateTask(data.id, { message, status: 'FAILED' });
             if (task && ui.isFunction(onTaskError))
-                onTaskError(task, e);
-            if (task && ui.isFunction(onError))
-                onError(data, e?.message);
-            updateTask(data.id, { message: e.message, status: 'FAILED' });
+                onTaskError(task, error);
         })
             .finally(() => {
             const task = getTask();
@@ -3030,52 +3185,54 @@ const useProcessTasks = (handler, items, options) => {
         { isProcessing, isProcessingComplete, reset, statusCounts, tasks },
         handleProcessTasks,
     ];
-};
-
-const DEFAULT_ACTION_CONCURRENCY = 4;
-const USE_LIST_ERROR_MESSAGE = '`useList` must be called from within `StorageBrowser.Provider`';
+}
 
-const isTasksOptions = (value) => ui.isObject(value);
-const useHandler = (action, options) => {
-    const hasOptions = isTasksOptions(options);
-    const { items, onTaskSuccess } = options ?? {};
-    const getConfig = useGetActionInput();
-    const { location: { current }, } = useStore()[0];
-    const [state, processTask] = useProcessTasks(action, items, {
-        onTaskSuccess,
-        ...(items ? { concurrency: DEFAULT_ACTION_CONCURRENCY } : undefined),
+const isOptionsWithItems = (options) => !!options?.items;
+const isHandleTaskInput = (value) => !!value?.data;
+function useHandler(handler, options) {
+    const [state, handleProcessing] = useProcessTasks(handler, {
+        ...options,
+        concurrency: DEFAULT_ACTION_CONCURRENCY,
     });
-    const { reset, isProcessing, tasks } = state;
-    const handler = React__namespace["default"].useCallback((input) => {
-        const { location } = input ?? {};
-        const config = getConfig(location ?? current);
-        if (!hasOptions) {
-            // clean up previous state
+    const getConfig = useGetActionInput();
+    const { reset, isProcessing, tasks, ...rest } = state;
+    const handleDispatch = React__namespace["default"].useCallback((input) => {
+        const config = getConfig(input?.location);
+        const hasData = isHandleTaskInput(input);
+        // clean up previous state for atomic handler
+        if (hasData)
             reset();
-            processTask({ ...input, config });
-            return;
-        }
-        processTask({ config });
-    }, [current, getConfig, hasOptions, processTask, reset]);
-    return [
-        hasOptions ? state : { isProcessing, task: tasks?.[0] },
-        handler,
-    ];
-};
+        handleProcessing({
+            config,
+            ...(hasData ? { data: input.data } : undefined),
+        });
+    }, [getConfig, handleProcessing, reset]);
+    if (isOptionsWithItems(options)) {
+        return [{ ...rest, isProcessing, reset, tasks }, handleDispatch];
+    }
+    return [{ isProcessing, task: tasks?.[0] }, handleDispatch];
+}
 
 const ERROR_MESSAGE = '`useAction` must be called from within `StorageBrowser.Provider`';
-const useAction = (key, options) => {
-    if (key === 'listLocations' ||
-        key === 'listLocationItems') {
+function assertActionHandlerKey(key) {
+    if (key === 'listLocations' || key === 'listLocationItems') {
         throw new Error(`Value of \`${key}\` cannot be provided to \`useAction\``);
     }
-    const { handlers } = useActionHandlers({ errorMessage: ERROR_MESSAGE });
-    const handler = handlers?.[key];
-    if (!handler) {
+}
+function assertActionHandler(handler, key) {
+    if (typeof handler !== 'function') {
         throw new Error(`No handler found for value of \`${key}\` provided to \`useAction\``);
     }
+}
+const useAction = ((key, options) => {
+    assertActionHandlerKey(key);
+    const { handlers } = useActionHandlers({ errorMessage: ERROR_MESSAGE });
+    const handler = handlers?.[key];
+    assertActionHandler(handler, key);
     return useHandler(handler, options);
-};
+    // casting to allow usage of `UseAction` interface which ensures that
+    // the `options` param receives the correct typing
+});
 
 const useListLocations = () => {
     const { handlers } = useActionHandlers({
@@ -3121,7 +3278,6 @@ const LIST_ACTION_HOOKS = {
     locations: useListLocations,
 };
 const isListActionViewType = (value) => Object.keys(LIST_ACTION_HOOKS).includes(value);
-// @ts-expect-error
 const useList = (type) => {
     if (!isListActionViewType(type)) {
         throw new Error(`Value of \`${type}\` cannot be used to index \`useList\``);
@@ -3487,16 +3643,12 @@ FoldersTableControl.displayName = 'FoldersTable';
 
 function CopyViewProvider({ children, ...props }) {
     const { CopyView: displayText } = useDisplayText();
-    const { actionCancelLabel, actionDestinationLabel, actionExitLabel, actionStartLabel, getActionCompleteMessage, overwriteWarningMessage, searchPlaceholder, searchSubmitLabel, searchClearLabel, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, } = displayText;
-    const { destination, folders, isProcessing, isProcessingComplete, location, statusCounts, tasks, onActionCancel, onActionExit, onActionStart, onSelectDestination, onTaskRemove, } = props;
+    const { actionCancelLabel, actionDestinationLabel, actionExitLabel, actionStartLabel, getActionCompleteMessage, overwriteWarningMessage, searchPlaceholder, searchSubmitLabel, searchClearLabel, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, title, } = displayText;
+    const { destination, folders, isProcessing, isProcessingComplete, statusCounts, tasks: items, onActionCancel, onActionExit, onActionStart, onSelectDestination, onTaskRemove, } = props;
     const { hasNextPage, highestPageVisited, hasError: hasFoldersError, message: foldersErrorMessage, query, hasExhaustedSearch, isLoading, page, pageItems, onPaginate, onQuery, onSearchClear, onSearch, onSelectFolder, } = folders;
-    const { key: locationKey } = location ?? {};
-    const tableData = getActionViewTableData({
-        tasks,
-        locationKey,
-        isProcessing,
-        displayText,
-        onTaskRemove,
+    const tableData = useResolveDataTable(COPY_TABLE_KEYS, COPY_TABLE_RESOLVERS, {
+        items,
+        props: { displayText, isProcessing, onTaskRemove },
     });
     const isActionStartDisabled = isProcessing || isProcessingComplete || !destination?.current;
     const isActionCancelDisabled = !isProcessing || isProcessingComplete;
@@ -3528,46 +3680,45 @@ function CopyViewProvider({ children, ...props }) {
             statusDisplayFailedLabel,
             statusDisplayQueuedLabel,
             tableData,
+            title,
         }, onActionCancel: onActionCancel, onActionExit: onActionExit, onActionStart: onActionStart, onSearch: onSearch, onSearchClear: onSearchClear, onSearchQueryChange: onQuery, onSelectDestination: onSelectDestination },
         React__namespace["default"].createElement(FoldersPaginationProvider, { hasNextPage: hasNextPage, highestPageVisited: highestPageVisited, page: page, onPaginate: onPaginate },
             React__namespace["default"].createElement(FoldersTableProvider, { destination: destination, folders: pageItems, onSelectFolder: onSelectFolder },
                 React__namespace["default"].createElement(FoldersMessageProvider, { folders: folders.pageItems, hasError: hasFoldersError, message: foldersErrorMessage, query: query, hasExhaustedSearch: hasExhaustedSearch }, children)))));
 }
 
-const usePaginate = ({ hasNextToken, items, paginateCallback, pageSize, }) => {
-    const [currentPage, setCurrentPage] = React__namespace["default"].useState(1);
+const DEFAULT_PAGE_SIZE$3 = 100;
+const usePaginate = ({ items, onPaginate, page = 1, pageSize = DEFAULT_PAGE_SIZE$3, }) => {
+    const [currentPage, setCurrentPage] = React__namespace["default"].useState(page);
+    const visitedRef = React__namespace["default"].useRef(page);
     const handleReset = React__namespace["default"].useRef(() => {
-        setCurrentPage(1);
+        setCurrentPage(page);
+        // set `visitedRef` to initially provided `page`
+        visitedRef.current = page;
     }).current;
     return React__namespace["default"].useMemo(() => {
-        const resultCount = Array.isArray(items) ? items.length : 0;
-        const highestPageVisited = Math.ceil(resultCount / pageSize);
+        const hasItems = Array.isArray(items);
+        const highestPageVisited = visitedRef.current;
         const isFirstPage = currentPage === 1;
         const start = isFirstPage ? 0 : (currentPage - 1) * pageSize;
         const end = isFirstPage ? pageSize : currentPage * pageSize;
-        const pageItems = Array.isArray(items) ? items.slice(start, end) : [];
+        const pageItems = hasItems ? items.slice(start, end) : [];
         return {
             currentPage,
-            onPaginate: (page) => {
-                const shouldPaginate = page >= 1 && (page <= highestPageVisited || hasNextToken);
-                if (shouldPaginate) {
-                    if (ui.isFunction(paginateCallback))
-                        paginateCallback();
-                    setCurrentPage(page);
-                }
+            handlePaginate: (page) => {
+                if (page < 1)
+                    return;
+                if (ui.isFunction(onPaginate))
+                    onPaginate(page);
+                if (page > currentPage)
+                    visitedRef.current = page;
+                setCurrentPage(page);
             },
             handleReset,
             highestPageVisited,
             pageItems,
         };
-    }, [
-        currentPage,
-        handleReset,
-        hasNextToken,
-        items,
-        paginateCallback,
-        pageSize,
-    ]);
+    }, [currentPage, handleReset, items, onPaginate, pageSize]);
 };
 
 function useSearch(props) {
@@ -3612,20 +3763,19 @@ const useFolders = ({ destination, setDestination, }) => {
             options: { ...DEFAULT_REFRESH_OPTIONS },
         });
     }, [handleList, key]);
-    const hasNextToken = !!nextToken;
-    const paginateCallback = () => {
-        if (!nextToken)
+    const hasNextPage = !!nextToken;
+    const onPaginate = () => {
+        if (!hasNextPage)
             return;
         handleList({
             prefix: key,
             options: { ...DEFAULT_LIST_OPTIONS$2, nextToken },
         });
     };
-    const { currentPage: page, onPaginate, highestPageVisited, pageItems, handleReset, } = usePaginate({
+    const { currentPage: page, handlePaginate, highestPageVisited, pageItems, handleReset, } = usePaginate({
         items,
-        paginateCallback,
+        onPaginate,
         pageSize: DEFAULT_PAGE_SIZE$2,
-        hasNextToken,
     });
     const onSearch = (query) => {
         handleReset();
@@ -3651,7 +3801,7 @@ const useFolders = ({ destination, setDestination, }) => {
     };
     return {
         hasError,
-        hasNextPage: hasNextToken,
+        hasNextPage,
         highestPageVisited,
         isLoading,
         message,
@@ -3660,7 +3810,7 @@ const useFolders = ({ destination, setDestination, }) => {
         pageItems,
         query,
         hasExhaustedSearch,
-        onPaginate,
+        onPaginate: handlePaginate,
         onQuery,
         onSearch: onSearchSubmit,
         onSearchClear: () => {
@@ -3796,16 +3946,13 @@ CopyView.Title = TitleControl;
 function DeleteViewProvider({ children, ...props }) {
     const { DeleteView: displayText } = useDisplayText();
     const { actionCancelLabel, actionExitLabel, actionStartLabel, title, statusDisplayCanceledLabel, statusDisplayCompletedLabel, statusDisplayFailedLabel, statusDisplayQueuedLabel, getActionCompleteMessage, } = displayText;
-    const { isProcessing, isProcessingComplete, location, statusCounts, tasks, onActionCancel, onActionStart, onActionExit, onTaskRemove, } = props;
+    const { isProcessing, isProcessingComplete, statusCounts, tasks: items, onActionCancel, onActionStart, onActionExit, onTaskRemove, } = props;
     const message = isProcessingComplete
         ? getActionCompleteMessage({ counts: statusCounts })
         : undefined;
-    const tableData = getActionViewTableData({
-        tasks,
-        locationKey: location.key,
-        isProcessing,
-        displayText,
-        onTaskRemove,
+    const tableData = useResolveDataTable(DELETE_TABLE_KEYS, DELETE_TABLE_RESOLVERS, {
+        items,
+        props: { displayText, isProcessing, onTaskRemove },
     });
     return (React__namespace["default"].createElement(ControlsContextProvider, { data: {
             actionCancelLabel,
@@ -3825,18 +3972,14 @@ function DeleteViewProvider({ children, ...props }) {
         }, onActionStart: onActionStart, onActionExit: onActionExit, onActionCancel: onActionCancel }, children));
 }
 
+// assign to constant to ensure referential equality
+const EMPTY_ITEMS = [];
 const useDeleteView = (options) => {
     const { onExit: _onExit } = options ?? {};
     const [{ location, locationItems }, dispatchStoreAction] = useStore();
-    const { fileDataItems } = locationItems;
-    const { current, key } = location;
-    const data = React__namespace["default"].useMemo(() => !fileDataItems
-        ? []
-        : fileDataItems.map((item) => ({
-            ...item,
-            key: `${key}${item.fileKey}`,
-        })), [fileDataItems, key]);
-    const [processState, handleProcess] = useAction('delete', { items: data });
+    const { current } = location;
+    const { fileDataItems: items = EMPTY_ITEMS } = locationItems;
+    const [processState, handleProcess] = useAction('delete', { items });
     const { isProcessing, isProcessingComplete, statusCounts, tasks } = processState;
     const onActionStart = () => {
         if (!current)
@@ -4034,8 +4177,7 @@ const useLocationDetailView = (options) => {
     // set up pagination
     const { items, nextToken, search } = data;
     const { hasExhaustedSearch = false } = search ?? {};
-    const hasNextToken = !!nextToken;
-    const paginateCallback = () => {
+    const onPaginate = () => {
         if (hasInvalidPrefix || !nextToken)
             return;
         dispatchStoreAction({ type: 'RESET_LOCATION_ITEMS' });
@@ -4044,11 +4186,10 @@ const useLocationDetailView = (options) => {
             options: { ...listOptions, nextToken },
         });
     };
-    const { currentPage, onPaginate, handleReset, highestPageVisited, pageItems, } = usePaginate({
+    const { currentPage, handlePaginate, handleReset, highestPageVisited, pageItems, } = usePaginate({
         items,
-        paginateCallback,
+        onPaginate,
         pageSize: listOptions.pageSize,
-        hasNextToken,
     });
     const onSearch = (query, includeSubfolders) => {
         if (hasInvalidPrefix)
@@ -4116,13 +4257,13 @@ const useLocationDetailView = (options) => {
         fileDataItems,
         hasError,
         hasDownloadError: task?.status === 'FAILED',
-        hasNextPage: hasNextToken,
+        hasNextPage: !!nextToken,
         highestPageVisited,
         message,
         downloadErrorMessage: getDownloadErrorMessageFromFailedDownloadTask(task),
         isLoading,
         isSearchSubfoldersEnabled,
-        onPaginate,
+        onPaginate: handlePaginate,
         searchQuery,
         hasExhaustedSearch,
         onRefresh,
@@ -4178,10 +4319,7 @@ const useLocationDetailView = (options) => {
             resetSearch();
             if (hasInvalidPrefix)
                 return;
-            handleList({
-                prefix: key,
-                options: { ...listOptions, refresh: true },
-            });
+            handleList({ prefix: key, options: { ...listOptions, refresh: true } });
             handleReset();
         },
         onSearchQueryChange,
@@ -4688,16 +4826,15 @@ const useLocationsView = (options) => {
         handleList({ options: { ...listOptions, refresh: true } });
     }, [handleList, listOptions]);
     // set up pagination
-    const paginateCallback = () => {
+    const onPaginate = () => {
         if (!nextToken)
             return;
         handleList({ options: { ...listOptions, nextToken } });
     };
-    const { currentPage, onPaginate, handleReset, highestPageVisited, pageItems, } = usePaginate({
+    const { currentPage, handlePaginate, handleReset, highestPageVisited, pageItems, } = usePaginate({
         items,
-        paginateCallback,
+        onPaginate,
         pageSize: listOptions.pageSize,
-        hasNextToken,
     });
     const onSearch = (query) => {
         handleReset();
@@ -4744,7 +4881,7 @@ const useLocationsView = (options) => {
             handleReset();
             handleList({ options: { ...listOptions, refresh: true } });
         },
-        onPaginate,
+        onPaginate: handlePaginate,
         onSearch: onSearchSubmit,
         onSearchQueryChange,
         onSearchClear: () => {
@@ -4808,7 +4945,10 @@ const getViews = (views, customConfigs) => {
             // ignore custom actions that are only handlers
             return !ui.isObject(config) || ui.isFunction(config)
                 ? acc
-                : { ...acc, [key]: views?.[config.viewName] };
+                : {
+                    ...acc,
+                    [key]: views?.[config.viewName],
+                };
         }, {});
     return {
         action: { ...resolvedDefaultActionViews, ...customActionViews },
@@ -4833,7 +4973,7 @@ function useViews() {
     };
 }
 
-const DEFAULT_VIEW_HOOKS = {
+const USE_VIEW_HOOKS = {
     Copy: useCopyView,
     CreateFolder: useCreateFolderView,
     Delete: useDeleteView,
@@ -4841,13 +4981,12 @@ const DEFAULT_VIEW_HOOKS = {
     Locations: useLocationsView,
     Upload: useUploadView,
 };
-const isUseViewType = (value) => !!DEFAULT_VIEW_HOOKS?.[value];
-// @ts-expect-error
+const isUseViewType = (value) => !!USE_VIEW_HOOKS?.[value];
 const useView = (type) => {
     if (!isUseViewType(type)) {
         throw new Error(`Value of \`${type}\` cannot be used to index \`useView\``);
     }
-    return DEFAULT_VIEW_HOOKS[type]();
+    return USE_VIEW_HOOKS[type]();
 };
 
 /**
@@ -4870,6 +5009,12 @@ function StorageBrowserDefault() {
     return React__namespace["default"].createElement(LocationsView, null);
 }
 
+/**
+ * Creates a `StorageBrowser` component and utility hooks from provided configuration `input`.
+ *
+ * @param input - `StorageBrowser` auth, actions and ui configuration values
+ * @returns `StorageBrowser` component, `useAction` and `useView` hooks
+ */
 function createStorageBrowser(input) {
     assertRegisterAuthListener(input.config.registerAuthListener);
     const { accountId, customEndpoint, registerAuthListener, getLocationCredentials, region, } = input.config;
@@ -5071,5 +5216,7 @@ exports.VERSION = VERSION;
 exports.componentsDefault = componentsDefault;
 exports.createAmplifyAuthAdapter = createAmplifyAuthAdapter;
 exports.createStorageBrowser = createStorageBrowser;
+exports.defaultActionConfigs = defaultActionConfigs;
+exports.defaultHandlers = defaultHandlers;
 exports.getFilteredLocations = getFilteredLocations;
 exports.toAccessGrantPermission = toAccessGrantPermission;