@aws-amplify/ui-react-storage 3.15.0 → 3.17.0

package/dist/{createStorageBrowser-CG-6mXiT.js → createStorageBrowser-De4hcP-u.js}

@@ -36,7 +36,7 @@ function _interopNamespace(e) {
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
 var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
 
-const VERSION = '3.15.0';
+const VERSION = '3.17.0';
 
 const DEFAULT_CHECKSUM_ALGORITHM = 'crc-32';
 // 5MiB for multipart upload
@@ -422,27 +422,58 @@ const createFolderHandler = (input) => {
     };
 };
 
-const deleteHandler = ({ config, data, }) => {
+const deleteHandler = ({ config, data, options, }) => {
     const { key } = data;
     const { accountId, credentials, customEndpoint } = config;
-    const result = internals.remove({
+    const { onProgress } = options ?? {};
+    let cumulativeSuccessCount = 0;
+    let cumulativeFailureCount = 0;
+    let operationCancel = () => {
+        // noop
+    };
+    const cancel = () => {
+        operationCancel?.();
+    };
+    const operation = internals.remove({
         path: key,
         options: {
             bucket: constructBucket$1(config),
             locationCredentialsProvider: credentials,
             expectedBucketOwner: accountId,
             customEndpoint,
+            onProgress: (progress) => {
+                if (!progress) {
+                    return;
+                }
+                const batchSuccessCount = progress?.deleted?.length ?? 0;
+                const batchFailureCount = progress?.failed?.length ?? 0;
+                cumulativeSuccessCount += batchSuccessCount;
+                cumulativeFailureCount += batchFailureCount;
+                onProgress?.(data, {
+                    successCount: cumulativeSuccessCount,
+                    failureCount: cumulativeFailureCount,
+                });
+            },
         },
+    });
+    operationCancel = operation?.cancel ? operation?.cancel : () => { };
+    const operationPromise = operation?.result ?? operation;
+    const result = operationPromise
+        ?.then?.(({ path }) => {
+        return {
+            status: 'COMPLETE',
+            value: {
+                key: path,
+                successCount: cumulativeSuccessCount,
+                failureCount: cumulativeFailureCount,
+            },
+        };
     })
-        .then(({ path }) => ({
-        status: 'COMPLETE',
-        value: { key: path },
-    }))
-        .catch((error) => {
+        ?.catch?.((error) => {
         const { message } = error;
         return { error, message, status: 'FAILED' };
     });
-    return { result };
+    return { result, cancel };
 };
 
 const zipProgressManager = ({ dataMap, onZipProgress, }) => {
@@ -634,7 +665,7 @@ const downloadHandler = (() => {
     return handler;
 })();
 
-const DEFAULT_PAGE_SIZE$5 = 1000;
+const DEFAULT_PAGE_SIZE$2 = 1000;
 const parseItems = (items, excludedPath) => items
     // remove root `key` from results
     .filter(({ path }) => path !== excludedPath)
@@ -667,7 +698,7 @@ const parseResult = ({ excludedSubpaths, items }, prefix) => filterDotItems([...
 const listLocationItemsHandler = async (input) => {
     const { config, prefix, options } = input;
     const { bucket: _bucket, credentials, customEndpoint, region: globalRegion, accountId, } = config;
-    const { exclude, delimiter, nextToken, pageSize: _pageSize = DEFAULT_PAGE_SIZE$5, ..._options } = options ?? {};
+    const { exclude, delimiter, nextToken, pageSize: _pageSize = DEFAULT_PAGE_SIZE$2, ..._options } = options ?? {};
     const bucketRegion = getBucketRegion(_bucket, globalRegion);
     const bucket = { bucketName: _bucket, region: bucketRegion };
     const subpathStrategy = {
@@ -792,10 +823,50 @@ const defaultValue$7 = {
 };
 const { useActionConfigs, ActionConfigsProvider } = uiReactCore.createContextUtilities({ contextName: 'ActionConfigs', defaultValue: defaultValue$7 });
 
+/**
+ * Selection utility functions for LocationItems
+ */
+/**
+ * Get selected files from dataItems
+ */
+const getSelectedFiles = (dataItems) => {
+    return dataItems?.filter((item) => item.type === 'FILE') ?? [];
+};
+/**
+ * Get selected folders from dataItems
+ */
+const getSelectedFolders = (dataItems) => {
+    return dataItems?.filter((item) => item.type === 'FOLDER') ?? [];
+};
+/**
+ * Check if selection contains folders
+ */
+const hasSelectedFolders = (dataItems) => {
+    return dataItems?.some((item) => item.type === 'FOLDER') ?? false;
+};
+/**
+ * Get selection summary
+ */
+const getSelectionSummary = (dataItems) => {
+    const files = getSelectedFiles(dataItems);
+    const folders = getSelectedFolders(dataItems);
+    return {
+        total: dataItems?.length ?? 0,
+        files: files.length,
+        folders: folders.length,
+        hasFiles: files.length > 0,
+        hasFolders: folders.length > 0,
+        isMixed: files.length > 0 && folders.length > 0,
+    };
+};
+
 const copyActionConfig = {
     viewName: 'CopyView',
     actionListItem: {
-        disable: (selected) => !selected || selected.length === 0,
+        disable: (selected) => {
+            const hasNoSelection = !selected || selected.length === 0;
+            return hasNoSelection || hasSelectedFolders(selected);
+        },
         hide: (permissions) => !permissions.includes('write'),
         icon: 'copy-file',
         label: 'Copy',
@@ -805,7 +876,10 @@ const copyActionConfig = {
 const deleteActionConfig = {
     viewName: 'DeleteView',
     actionListItem: {
-        disable: (selected) => !selected || selected.length === 0,
+        disable: (selected) => {
+            const hasNoSelection = !selected || selected.length === 0;
+            return hasNoSelection;
+        },
         hide: (permissions) => !permissions.includes('delete'),
         icon: 'delete-file',
         label: 'Delete',
@@ -833,7 +907,10 @@ const uploadActionConfig = {
 const downloadActionConfig = {
     viewName: 'DownloadView',
     actionListItem: {
-        disable: (selected) => !selected || selected.length === 0,
+        disable: (selected) => {
+            const hasNoSelection = !selected || selected.length === 0;
+            return hasNoSelection || hasSelectedFolders(selected);
+        },
         hide: (permissions) => !permissions.includes('get'),
         icon: 'download',
         label: 'Download',
@@ -1038,7 +1115,7 @@ const OrderedListElement = elements.defineBaseElement({
     type: 'ol',
     displayName: 'OrderedList',
 });
-elements.defineBaseElement({
+const UnorderedListElement = elements.defineBaseElement({
     type: 'ul',
     displayName: 'UnorderedList',
 });
@@ -1178,6 +1255,34 @@ const { useComposables, ComposablesProvider } = uiReactCore.createContextUtiliti
 
 const ActionCancel = ({ onCancel, isDisabled, label, }) => (React__namespace["default"].createElement(ButtonElement, { variant: "cancel", className: `${STORAGE_BROWSER_BLOCK}__cancel`, onClick: onCancel, disabled: isDisabled }, label));
 
+const ActionConfirmationModal = ({ isOpen = false, title, message, content, onConfirm, onCancel, confirmLabel, cancelLabel, }) => {
+    const modalRef = React__namespace["default"].useRef(null);
+    React__namespace["default"].useEffect(() => {
+        if (isOpen && modalRef.current) {
+            modalRef.current.focus();
+        }
+    }, [isOpen]);
+    const handleKeyDown = (event) => {
+        if (event.key === 'Escape') {
+            onCancel?.();
+        }
+    };
+    if (!isOpen)
+        return null;
+    return (React__namespace["default"].createElement("div", { ref: modalRef, className: "amplify-modal__overlay", role: "dialog", "aria-modal": "true", tabIndex: -1, onKeyDown: handleKeyDown, onClick: (e) => {
+            if (e.target === e.currentTarget) {
+                onCancel?.();
+            }
+        } },
+        React__namespace["default"].createElement(ViewElement, { className: "amplify-modal__content", role: "document" },
+            React__namespace["default"].createElement(HeadingElement, { className: "amplify-modal__title" }, title),
+            message && (React__namespace["default"].createElement(TextElement, { className: "amplify-modal__body" }, message)),
+            content && (React__namespace["default"].createElement(ViewElement, { className: "amplify-modal__body" }, content)),
+            React__namespace["default"].createElement(ViewElement, { className: "amplify-modal__footer" },
+                React__namespace["default"].createElement(ButtonElement, { className: "amplify-modal__cancel", onClick: onCancel, variant: "cancel" }, cancelLabel),
+                React__namespace["default"].createElement(ButtonElement, { className: "amplify-modal__confirm", onClick: onConfirm, variant: "primary" }, confirmLabel)))));
+};
+
 const ActionDestination$1 = ({ isNavigable, items, label, }) => {
     if (!items.length) {
         return null;
@@ -1709,10 +1814,10 @@ function useCredentialsStore({ getLocationCredentials: handler, initialValue, on
     return store;
 }
 
-const ERROR_MESSAGE$2 = '`useCredentials` must be called from within a `CredentialsProvider`.';
+const ERROR_MESSAGE$3 = '`useCredentials` must be called from within a `CredentialsProvider`.';
 const { useCredentials, CredentialsContext } = uiReactCore.createContextUtilities({
     contextName: 'Credentials',
-    errorMessage: ERROR_MESSAGE$2,
+    errorMessage: ERROR_MESSAGE$3,
 });
 function CredentialsProvider({ children, ...props }) {
     const initialValue = React__namespace["default"].useContext(CredentialsContext);
@@ -1804,7 +1909,7 @@ const DEPRECATED_PROP_KEYS = ['actionType', 'location', 'path'];
 const template = (key, index, values) => `\`${key}\`${index < values.length - 1 ? ', ' : ''}`;
 const getMissingLocationKeys = (location) => location === null
     ? []
-    : REQUIRED_LOCATION_KEYS.filter((key) => !location[key]);
+    : REQUIRED_LOCATION_KEYS.filter((key) => location[key] === undefined || location[key] === null);
 let didWarnConflictingBehavior = false;
 let didWarnDeprecatedAndConflictingProps = false;
 let didWarnDeprecatedProps = false;
@@ -1912,10 +2017,10 @@ function useGetActionInputCallback({ accountId, customEndpoint, region, }) {
     }, [accountId, current, customEndpoint, getCredentials, key, region]);
 }
 
-const ERROR_MESSAGE$1 = '`useGetActionInput` must be called from within a `ConfigurationProvider`.';
+const ERROR_MESSAGE$2 = '`useGetActionInput` must be called from within a `ConfigurationProvider`.';
 const { useGetActionInput, GetActionInputContext } = uiReactCore.createContextUtilities({
     contextName: 'GetActionInput',
-    errorMessage: ERROR_MESSAGE$1,
+    errorMessage: ERROR_MESSAGE$2,
 });
 function GetActionInputProvider({ accountId, children, customEndpoint, region, }) {
     const value = useGetActionInputCallback({
@@ -1937,6 +2042,27 @@ function createConfigurationProvider(input) {
     return Provider;
 }
 
+const DEFAULT_PAGE_SIZE$1 = 100;
+const validatePageSize = (pageSize) => {
+    if (pageSize === undefined ||
+        pageSize === null ||
+        !Number.isInteger(pageSize) ||
+        pageSize < 1) {
+        return DEFAULT_PAGE_SIZE$1;
+    }
+    return pageSize;
+};
+
+const ERROR_MESSAGE$1 = '`usePaginationConfig` must be called from within a `PaginationConfigProvider`.';
+const { usePaginationConfig, PaginationConfigContext } = uiReactCore.createContextUtilities({
+    contextName: 'PaginationConfig',
+    errorMessage: ERROR_MESSAGE$1,
+});
+function PaginationConfigProvider({ children, pageSize, }) {
+    const value = React__namespace["default"].useMemo(() => ({ pageSize: validatePageSize(pageSize) }), [pageSize]);
+    return (React__namespace["default"].createElement(PaginationConfigContext.Provider, { value: value }, children));
+}
+
 const DEFAULT_ACTION_CONCURRENCY = 4;
 const USE_LIST_ERROR_MESSAGE = '`useList` must be called from within `StorageBrowser.Provider`';
 
@@ -2065,16 +2191,19 @@ function useProcessTasks(handler, options) {
         const getTask = () => tasksRef.current.get(data.id);
         const { options } = _input;
         const { onProgress: _onProgress } = options ?? {};
-        const onProgress = ({ id }, progress, status = 'PENDING') => {
+        const onProgress = ({ id }, progressDetails, status = 'PENDING') => {
+            const isNumber = typeof progressDetails === 'number';
             const task = updateTask(id, {
-                progress,
+                progress: isNumber ? progressDetails : progressDetails.progress,
+                failureCount: isNumber ? undefined : progressDetails.failureCount,
+                successCount: isNumber ? undefined : progressDetails.successCount,
                 status,
             });
             if (task && ui.isFunction(onTaskProgress)) {
-                onTaskProgress(task, progress);
+                onTaskProgress(task, progressDetails);
             }
             if (task && ui.isFunction(_onProgress)) {
-                _onProgress(data, progress, status);
+                _onProgress(data, progressDetails, status);
             }
         };
         const input = { ..._input, data, all, options: { ...options, onProgress } };
@@ -2284,6 +2413,7 @@ const DEFAULT_ACTION_VIEW_DISPLAY_TEXT = {
     tableColumnNameHeader: 'Name',
     tableColumnTypeHeader: 'Type',
     tableColumnSizeHeader: 'Size',
+    tableColumnProgressHeader: 'Progress',
 };
 const DEFAULT_LIST_VIEW_DISPLAY_TEXT = {
     loadingIndicatorLabel: 'Loading',
@@ -2376,21 +2506,133 @@ const DEFAULT_COPY_VIEW_DISPLAY_TEXT = {
     searchClearLabel: 'Clear search',
 };
 
+const pluralize = (count, word) => count === 1 ? word : `${word}s`;
+const formatCount = (count, word) => `${count === 1 ? '' : 'All '}${count} ${pluralize(count, word)}`;
 const DEFAULT_DELETE_VIEW_DISPLAY_TEXT = {
     ...DEFAULT_ACTION_VIEW_DISPLAY_TEXT,
     title: 'Delete',
     actionStartLabel: 'Delete',
+    confirmationModalTitle: 'Confirm Deletion',
+    confirmationModalConfirmLabel: 'Delete',
+    confirmationModalCancelLabel: 'Cancel',
+    confirmationModalMessage: 'The items that will be deleted contain {count} folder{plural}',
+    confirmationModalFolderListTitle: 'Folder list:',
     getActionCompleteMessage: (data) => {
-        const { counts } = data ?? {};
-        const { COMPLETE, FAILED, TOTAL } = counts ?? {};
+        const { counts, tasks } = data ?? {};
+        const { COMPLETE = 0, FAILED = 0, TOTAL = 0 } = counts ?? {};
+        if (!TOTAL || TOTAL === 0) {
+            return { content: 'No items to delete.', type: 'info' };
+        }
+        if (tasks && tasks.length > 0) {
+            const folderTasks = tasks.filter((task) => task.data.type === 'FOLDER');
+            const fileTasks = tasks.filter((task) => task.data.type === 'FILE');
+            const completeFolders = folderTasks.filter((task) => task.status === 'COMPLETE').length;
+            const failedFolders = folderTasks.filter((task) => task.status === 'FAILED').length;
+            const completeFiles = fileTasks.filter((task) => task.status === 'COMPLETE').length;
+            const failedFiles = fileTasks.filter((task) => task.status === 'FAILED').length;
+            const hasFolders = folderTasks.length > 0;
+            const hasFiles = fileTasks.length > 0;
+            const isMixed = hasFolders && hasFiles;
+            // All successful
+            if (COMPLETE === TOTAL) {
+                if (isMixed) {
+                    return {
+                        content: `${formatCount(completeFolders, 'folder')} and ${completeFiles} ${pluralize(completeFiles, 'file')} deleted successfully.`,
+                        type: 'success',
+                    };
+                }
+                else if (hasFolders) {
+                    return {
+                        content: `${formatCount(completeFolders, 'folder')} deleted successfully.`,
+                        type: 'success',
+                    };
+                }
+                else {
+                    return {
+                        content: `${formatCount(completeFiles, 'file')} deleted successfully.`,
+                        type: 'success',
+                    };
+                }
+            }
+            // Complete failure
+            if (FAILED === TOTAL) {
+                if (isMixed) {
+                    return {
+                        content: `Failed to delete ${failedFolders} ${pluralize(failedFolders, 'folder')} and ${failedFiles} ${pluralize(failedFiles, 'file')}. Some contents may have been deleted.`,
+                        type: 'error',
+                    };
+                }
+                else if (hasFolders) {
+                    return {
+                        content: `Failed to delete ${failedFolders} ${pluralize(failedFolders, 'folder')}. Some items may have been deleted.`,
+                        type: 'error',
+                    };
+                }
+                else {
+                    return {
+                        content: `Failed to delete ${failedFiles} ${pluralize(failedFiles, 'file')}.`,
+                        type: 'error',
+                    };
+                }
+            }
+            // Partial failure
+            if (isMixed) {
+                const messages = [];
+                if (completeFiles > 0) {
+                    messages.push(`${completeFiles} ${pluralize(completeFiles, 'file')} deleted`);
+                }
+                if (completeFolders > 0) {
+                    messages.push(`${completeFolders} ${pluralize(completeFolders, 'folder')} deleted`);
+                }
+                if (failedFiles > 0) {
+                    messages.push(`${failedFiles} ${pluralize(failedFiles, 'file')} failed`);
+                }
+                if (failedFolders > 0) {
+                    messages.push(`${failedFolders} ${pluralize(failedFolders, 'folder')} failed`);
+                }
+                return {
+                    content: messages.join(', ') + '. Some items may have been deleted.',
+                    type: 'error',
+                };
+            }
+            else if (hasFolders) {
+                // Folders only partial failure
+                if (completeFolders > 0) {
+                    return {
+                        content: `${completeFolders} ${pluralize(completeFolders, 'folder')} deleted, ${failedFolders} ${pluralize(failedFolders, 'folder')} failed. Some items may have been deleted.`,
+                        type: 'error',
+                    };
+                }
+                else {
+                    return {
+                        content: `Failed to delete ${failedFolders} ${pluralize(failedFolders, 'folder')}. Some items may have been deleted.`,
+                        type: 'error',
+                    };
+                }
+            }
+            else {
+                // Files only partial failure
+                return {
+                    content: `${completeFiles} ${pluralize(completeFiles, 'file')} deleted, ${failedFiles} ${pluralize(failedFiles, 'file')} failed.`,
+                    type: 'error',
+                };
+            }
+        }
+        // Fallback to generic messaging if tasks not available
         if (COMPLETE === TOTAL) {
-            return { content: 'All files deleted.', type: 'success' };
+            return {
+                content: `${formatCount(TOTAL, 'item')} deleted successfully.`,
+                type: 'success',
+            };
         }
         if (FAILED === TOTAL) {
-            return { content: 'All files failed to delete.', type: 'error' };
+            return {
+                content: `Failed to delete ${formatCount(TOTAL, 'item')}.`,
+                type: 'error',
+            };
         }
         return {
-            content: `${COMPLETE} files deleted, ${FAILED} files failed to delete.`,
+            content: `${COMPLETE} ${pluralize(COMPLETE, 'item')} deleted, ${FAILED} ${pluralize(FAILED, 'item')} failed to delete.`,
             type: 'error',
         };
     },
@@ -2465,6 +2707,7 @@ const DEFAULT_LOCATION_DETAIL_VIEW_DISPLAY_TEXT = {
     tableColumnSizeHeader: 'Size',
     tableColumnTypeHeader: 'Type',
     selectFileLabel: 'Select file',
+    selectFolderLabel: 'Select folder',
     selectAllFilesLabel: 'Select all files',
     getActionListItemLabel: (key = '') => {
         switch (key) {
@@ -3287,6 +3530,7 @@ const Title$1 = ({ title }) => (React__namespace["default"].createElement(Headin
 
 const DEFAULT_COMPOSABLES = {
     ActionCancel,
+    ActionConfirmationModal,
     ActionDestination: ActionDestination$1,
     ActionExit,
     ActionStart,
@@ -3477,6 +3721,26 @@ const ActionCancelControl = () => {
     return React__namespace["default"].createElement(Resolved, { ...props });
 };
 
+const useActionConfirmationModal = () => {
+    const { data: { confirmationModal = {} }, onConfirmationModalConfirm = () => { }, onConfirmationModalCancel = () => { }, } = useControlsContext();
+    return {
+        isOpen: false,
+        title: 'Confirm Action',
+        message: '',
+        confirmLabel: 'Confirm',
+        cancelLabel: 'Cancel',
+        ...confirmationModal,
+        onConfirm: onConfirmationModalConfirm,
+        onCancel: onConfirmationModalCancel,
+    };
+};
+
+const ActionConfirmationModalControl = () => {
+    const props = useActionConfirmationModal();
+    const Resolved = useResolvedComposable(ActionConfirmationModal, 'ActionConfirmationModal');
+    return React__namespace["default"].createElement(Resolved, { ...props });
+};
+
 const getNavigationItems = ({ destinationParts, location, onNavigate, }) => {
     const { bucket, permissions, prefix = '', type } = location;
     const destinationSubpaths = [];
@@ -4011,9 +4275,18 @@ const FILE_DATA_ITEM_TABLE_KEYS = [
     'status',
     'cancel',
 ];
+const DELETE_TABLE_KEYS = [
+    'name',
+    'folder',
+    'type',
+    'size',
+    'status',
+    'progress',
+    'cancel',
+];
 
-const getFileType = (value, fallback = '') => value.lastIndexOf('.') !== -1
-    ? value.slice(value.lastIndexOf('.') + 1)
+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
@@ -4028,7 +4301,7 @@ const getFileDataCellFolder = (task) => {
         ? task.data.sourceKey
         : task.data.key;
     const { fileKey } = task.data;
-    return targetKey.slice(0, -fileKey.length);
+    return targetKey.slice(0, -fileKey?.length);
 };
 const getUploadCellProgress = ({ progress, status, }) => {
     // prefer `progress` if available, 1 if status is complete, default 0
@@ -4073,31 +4346,31 @@ const getFileDataCancelCellContent = (data) => {
  * Generates a unique key for a table cell based on the key and item id
  */
 const getFileDataCellKey = ({ key, item, }) => `${key}-${item.data.id}`;
-const name$2 = (data) => {
+const name$3 = (data) => {
     const key = getFileDataCellKey(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 folder$3 = (data) => {
     const key = getFileDataCellKey(data);
     const text = getFileDataCellFolder(data.item);
     return { key, type: 'text', content: { text } };
 };
-const type$2 = (data) => {
+const type$3 = (data) => {
     const key = getFileDataCellKey(data);
     const { fileKey } = data.item.data;
     const text = getFileType(fileKey);
     return { key, type: 'text', content: { text } };
 };
-const size$2 = (data) => {
+const size$3 = (data) => {
     const key = getFileDataCellKey(data);
     const { size: value } = data.item.data;
     const displayValue = getFileSize(value);
     return { key, type: 'number', content: { value, displayValue } };
 };
-const cancel$2 = (data) => {
+const cancel$3 = (data) => {
     const key = getFileDataCellKey(data);
     const content = getFileDataCancelCellContent(data);
     return { key, type: 'button', content };
@@ -4113,12 +4386,12 @@ const status$3 = (data) => {
     return { key, type: 'text', content: { text } };
 };
 const COPY_CELL_RESOLVERS = {
-    name: name$2,
-    folder: folder$2,
-    type: type$2,
-    size: size$2,
+    name: name$3,
+    folder: folder$3,
+    type: type$3,
+    size: size$3,
     status: status$3,
-    cancel: cancel$2,
+    cancel: cancel$3,
     /**
      * @deprecated
      *
@@ -4140,8 +4413,160 @@ const COPY_TABLE_RESOLVERS = {
     getRowKey: ({ item }) => item.data.id,
 };
 
+const getFolderName = (folderKey) => {
+    return folderKey.replace(/\/$/, '').split('/').pop() ?? folderKey;
+};
+/**
+ * Creates JSX content showing a list of folders to be deleted
+ */
+const createFolderListContent = (folders, folderListTitle) => {
+    return (React__namespace["default"].createElement(React__namespace["default"].Fragment, null,
+        React__namespace["default"].createElement(TextElement, { className: "amplify-modal__list-title" },
+            React__namespace["default"].createElement("strong", null, folderListTitle)),
+        React__namespace["default"].createElement(UnorderedListElement, { className: "amplify-modal__list" }, folders.map((folder) => (React__namespace["default"].createElement(ListItemElement, { key: folder.id, className: "amplify-modal__list-item" }, getFolderName(folder.key)))))));
+};
+const createDeleteConfirmationModalProps = ({ items, showConfirmation, displayText, }) => {
+    const folders = getSelectedFolders(items);
+    const folderCount = folders.length;
+    return {
+        isOpen: showConfirmation,
+        title: displayText.confirmationModalTitle,
+        message: displayText.confirmationModalMessage
+            .replace('{count}', folderCount.toString())
+            .replace('{plural}', folderCount !== 1 ? 's' : ''),
+        confirmLabel: displayText.confirmationModalConfirmLabel,
+        cancelLabel: displayText.confirmationModalCancelLabel,
+        content: createFolderListContent(folders, displayText.confirmationModalFolderListTitle),
+    };
+};
+/**
+ * Maximum number of files to count before showing "+" notation
+ * This prevents expensive operations on very large folders
+ */
+const MAX_FILE_COUNT_LIMIT = 5000;
+const LIST_PAGE_SIZE = 1000;
+/**
+ * Count the total number of files in a folder with pagination and limits
+ * @param folderKey - The folder path to count files in
+ * @param config - Storage configuration
+ * @returns Promise<number | string> - File count or "5000+" if exceeds limit
+ */
+const countFilesInFolder = async (folderKey, config) => {
+    try {
+        const { accountId, credentials, customEndpoint } = config;
+        const bucket = constructBucket$1(config);
+        let fileCount = 0;
+        let nextToken;
+        let hasMoreItems = true;
+        while (hasMoreItems && fileCount < MAX_FILE_COUNT_LIMIT) {
+            const { items, nextToken: listNextToken } = await internals.list({
+                path: folderKey,
+                options: {
+                    bucket,
+                    locationCredentialsProvider: credentials,
+                    expectedBucketOwner: accountId,
+                    customEndpoint,
+                    pageSize: LIST_PAGE_SIZE,
+                    nextToken,
+                },
+            });
+            const batchFileCount = items.filter((item) => !item.path.endsWith('/')).length;
+            fileCount += batchFileCount;
+            nextToken = listNextToken;
+            hasMoreItems = !!nextToken;
+            if (fileCount >= MAX_FILE_COUNT_LIMIT) {
+                return `${MAX_FILE_COUNT_LIMIT}+`;
+            }
+        }
+        if (hasMoreItems) {
+            return `${fileCount}+`;
+        }
+        return fileCount;
+    }
+    catch (error) {
+        return 0;
+    }
+};
+
+const getDeleteCellKey = (data) => `${data.key}-${data.item.data.id}`;
+const getCellDataFolder = (data) => {
+    const { type, key } = data;
+    const fileKey = getFileKey(key);
+    const targetKey = data.key;
+    if (type === 'FOLDER') {
+        const pathWithoutTrailingSlash = targetKey.replace(/\/$/, '');
+        const lastSlashIndex = pathWithoutTrailingSlash.lastIndexOf('/');
+        return lastSlashIndex >= 0
+            ? pathWithoutTrailingSlash.slice(0, lastSlashIndex + 1)
+            : '';
+    }
+    return targetKey.slice(0, -fileKey?.length);
+};
+const name$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    const { item } = data;
+    let text;
+    if (item.data.type === 'FOLDER') {
+        text = `${getFolderName(item.data.key)}/`;
+    }
+    else {
+        text = item.data.fileKey ?? getCellName(item.data.key);
+    }
+    const icon = STATUS_ICONS[item.status];
+    return { key, type: 'text', content: { icon, text } };
+};
+const folder$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    const text = getCellDataFolder(data.item.data);
+    return { key, type: 'text', content: { text } };
+};
+const type$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    if (data.item.data.type === 'FOLDER') {
+        return { key, type: 'text', content: { text: 'Folder' } };
+    }
+    const text = getFileType(data.item.data.key);
+    return { key, type: 'text', content: { text } };
+};
+const size$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    const itemData = data.item.data;
+    if (data.item.data.type === 'FOLDER') {
+        return { key, type: 'text', content: { text: '-' } };
+    }
+    const value = 'size' in itemData ? itemData.size : 0;
+    const displayValue = getFileSize(value);
+    return { key, type: 'number', content: { value, displayValue } };
+};
+const getCancelCellContent = (data) => {
+    const { item, props } = data;
+    const { cancel, status } = item;
+    const { isProcessing, onTaskRemove } = props;
+    const isQueued = status === 'QUEUED';
+    const isRemovable = isQueued && !isProcessing;
+    const isCancelable = isProcessing && !!cancel;
+    const itemAriaValue = getCellName(item.data.fileKey ?? item.data.key);
+    const ariaLabel = `${isRemovable ? 'Remove' : 'Cancel'} item: ${itemAriaValue}`;
+    const isDisabled = !isRemovable && !isCancelable;
+    const onClick = !isCancelable && !isRemovable
+        ? undefined
+        : () => {
+            if (isRemovable) {
+                onTaskRemove?.(item);
+                return;
+            }
+            if (isCancelable)
+                cancel();
+        };
+    return { ariaLabel, isDisabled, onClick, icon: 'cancel' };
+};
+const cancel$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    const content = getCancelCellContent(data);
+    return { key, type: 'button', content };
+};
 const status$2 = (data) => {
-    const key = getFileDataCellKey(data);
+    const key = getDeleteCellKey(data);
     const { item: { status }, props: { displayText }, } = data;
     const statusLabelKey = STATUS_LABELS[status];
     const text = isDeleteViewDisplayTextKey(statusLabelKey)
@@ -4149,21 +4574,47 @@ const status$2 = (data) => {
         : '';
     return { key, type: 'text', content: { text } };
 };
+const progress$2 = (data) => {
+    const key = getDeleteCellKey(data);
+    const { item } = data;
+    const itemIsFile = item.data.type === 'FILE';
+    if (itemIsFile) {
+        const text = item.status === 'COMPLETE' ? 'Deleted' : '-';
+        return { key, type: 'text', content: { text } };
+    }
+    if ((item.status === 'PENDING' ||
+        item.status === 'FAILED' ||
+        item.status === 'CANCELED') &&
+        item.data.totalCount !== undefined) {
+        const countDisplay = item.data.totalCount ?? '?';
+        const text = `${item.successCount ?? 0}/${countDisplay} files`;
+        return { key, type: 'text', content: { text } };
+    }
+    else if (item.status === 'COMPLETE') {
+        if (item.data.totalCount === null) {
+            const text = `${item.successCount ?? 0} files deleted`;
+            return { key, type: 'text', content: { text } };
+        }
+        const text = `${item.data.totalCount} files deleted`;
+        return { key, type: 'text', content: { text } };
+    }
+    else {
+        const text = item.data.totalCount === null
+            ? 'Count failed'
+            : item.data.totalCount !== undefined
+                ? `${item.data.totalCount} files`
+                : 'Calculating...';
+        return { key, type: 'text', content: { text } };
+    }
+};
 const DELETE_CELL_RESOLVERS = {
     name: name$2,
     folder: folder$2,
     type: type$2,
     size: size$2,
     status: status$2,
+    progress: progress$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 DELETE_TABLE_RESOLVERS = {
     getCell: (data) => DELETE_CELL_RESOLVERS[data.key](data),
@@ -4564,8 +5015,7 @@ function FileItemsProvider({ children, validateFile, }) {
 
 const DEFAULT_OVERWRITE_ENABLED = false;
 
-const DEFAULT_PAGE_SIZE$4 = 100;
-const usePaginate = ({ items, onPaginate, page = 1, pageSize = DEFAULT_PAGE_SIZE$4, }) => {
+const usePaginate = ({ items, onPaginate, page = 1, pageSize, }) => {
     const [currentPage, setCurrentPage] = React__namespace["default"].useState(page);
     const visitedRef = React__namespace["default"].useRef(page);
     const handleReset = React__namespace["default"].useRef(() => {
@@ -4575,19 +5025,31 @@ const usePaginate = ({ items, onPaginate, page = 1, pageSize = DEFAULT_PAGE_SIZE
     }).current;
     return React__namespace["default"].useMemo(() => {
         const hasItems = Array.isArray(items);
+        const totalItems = hasItems ? items.length : 0;
+        const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+        // Auto-adjust current page if it's beyond available pages
+        // For server-side pagination, don't auto-adjust if onPaginate callback is provided
+        let adjustedCurrentPage = currentPage;
+        if (currentPage > totalPages && !ui.isFunction(onPaginate)) {
+            adjustedCurrentPage = totalPages;
+            setCurrentPage(adjustedCurrentPage);
+        }
         const highestPageVisited = visitedRef.current;
-        const isFirstPage = currentPage === 1;
-        const start = isFirstPage ? 0 : (currentPage - 1) * pageSize;
-        const end = isFirstPage ? pageSize : currentPage * pageSize;
+        const isFirstPage = adjustedCurrentPage === 1;
+        const start = isFirstPage ? 0 : (adjustedCurrentPage - 1) * pageSize;
+        const end = isFirstPage ? pageSize : adjustedCurrentPage * pageSize;
         const pageItems = hasItems ? items.slice(start, end) : [];
         return {
-            currentPage,
+            currentPage: adjustedCurrentPage,
             handlePaginate: (page) => {
                 if (page < 1)
                     return;
+                // For server-side pagination, allow going beyond totalPages if onPaginate is provided
+                if (page > totalPages && !ui.isFunction(onPaginate))
+                    return;
                 if (ui.isFunction(onPaginate))
                     onPaginate(page);
-                if (page > currentPage && page > highestPageVisited)
+                if (page > adjustedCurrentPage && page > highestPageVisited)
                     visitedRef.current = page;
                 setCurrentPage(page);
             },
@@ -4598,9 +5060,10 @@ const usePaginate = ({ items, onPaginate, page = 1, pageSize = DEFAULT_PAGE_SIZE
     }, [currentPage, handleReset, items, onPaginate, pageSize]);
 };
 
-const DEFAULT_PAGE_SIZE$3 = 100;
 const useUploadView = (options) => {
-    const { onExit: _onExit } = options ?? {};
+    const { pageSize: configPageSize } = usePaginationConfig();
+    const { onExit: _onExit, pageSize: propPageSize } = options ?? {};
+    const pageSize = propPageSize ?? configPageSize;
     const [{ location }, storeDispatch] = useStore();
     const [{ validItems, invalidItems: invalidFiles }, fileItemsDispatch] = useFileItems();
     const { current } = location;
@@ -4613,6 +5076,7 @@ const useUploadView = (options) => {
     const [{ isProcessing, isProcessingComplete, statusCounts, tasks }, handleUploads,] = useAction('upload', { items });
     const { currentPage, handlePaginate, pageItems: pageTasks, } = usePaginate({
         items: tasks,
+        pageSize,
     });
     const onDropFiles = (files) => {
         if (files) {
@@ -4650,8 +5114,8 @@ const useUploadView = (options) => {
         statusCounts,
         tasks: pageTasks,
         page: currentPage,
-        hasNextPage: currentPage * DEFAULT_PAGE_SIZE$3 < items.length,
-        highestPageVisited: Math.ceil(items.length / DEFAULT_PAGE_SIZE$3),
+        hasNextPage: currentPage * pageSize < items.length,
+        highestPageVisited: Math.ceil(items.length / pageSize),
         onActionCancel,
         onActionExit,
         onActionStart,
@@ -4665,7 +5129,7 @@ const useUploadView = (options) => {
 
 const UploadView = ({ className, ...props }) => {
     const state = useUploadView(props);
-    return (React__namespace["default"].createElement(ViewElement, { className: ui.classNames(STORAGE_BROWSER_BLOCK, className) },
+    return (React__namespace["default"].createElement(ViewElement, { className: ui.classNames(STORAGE_BROWSER_BLOCK, className), "data-testid": "UPLOAD_VIEW" },
         React__namespace["default"].createElement(UploadViewProvider, { ...state },
             React__namespace["default"].createElement(ActionExitControl, null),
             React__namespace["default"].createElement(TitleControl, null),
@@ -4920,6 +5384,7 @@ function CopyViewProvider({ children, ...props }) {
 }
 
 const DEFAULT_STATE = {
+    dataItems: undefined,
     fileDataItems: undefined,
 };
 const locationItemsReducer = (prevState, event) => {
@@ -4928,27 +5393,29 @@ const locationItemsReducer = (prevState, event) => {
             const { items } = event;
             if (!items?.length)
                 return prevState;
-            if (!prevState.fileDataItems?.length) {
-                return { fileDataItems: items.map(createFileDataItem) };
-            }
-            const nextFileDataItems = items?.reduce((fileDataItems, data) => prevState.fileDataItems?.some(({ id }) => id === data.id)
-                ? fileDataItems
-                : fileDataItems.concat(createFileDataItem(data)), []);
-            if (!nextFileDataItems?.length)
-                return prevState;
+            const nextDataItems = !prevState.dataItems?.length
+                ? items
+                : prevState.dataItems.concat(items.filter((data) => !prevState.dataItems?.some(({ id }) => id === data.id)));
+            const fileItems = items.filter((item) => item.type === 'FILE');
+            const nextFileDataItems = !prevState.fileDataItems?.length
+                ? fileItems.map(createFileDataItem)
+                : prevState.fileDataItems.concat(fileItems
+                    .filter((data) => !prevState.fileDataItems?.some(({ id }) => id === data.id))
+                    .map(createFileDataItem));
             return {
-                fileDataItems: prevState.fileDataItems.concat(nextFileDataItems),
+                dataItems: nextDataItems,
+                fileDataItems: nextFileDataItems,
             };
         }
         case 'REMOVE_LOCATION_ITEM': {
             const { id } = event;
-            if (!prevState.fileDataItems)
-                return prevState;
-            const fileDataItems = prevState.fileDataItems.filter((item) => item.id !== id);
-            if (fileDataItems.length === prevState.fileDataItems.length) {
+            const dataItems = prevState.dataItems?.filter((item) => item.id !== id);
+            const fileDataItems = prevState.fileDataItems?.filter((item) => item.id !== id);
+            if (dataItems?.length === prevState.dataItems?.length &&
+                fileDataItems?.length === prevState.fileDataItems?.length) {
                 return prevState;
             }
-            return { fileDataItems };
+            return { dataItems, fileDataItems };
         }
         case 'RESET_LOCATION_ITEMS': {
             return DEFAULT_STATE;
@@ -4986,13 +5453,13 @@ function useSearch(props) {
     };
 }
 
-const DEFAULT_PAGE_SIZE$2 = 100;
-const DEFAULT_LIST_OPTIONS$2 = {
-    pageSize: DEFAULT_PAGE_SIZE$2,
+const DEFAULT_PAGE_SIZE = 100;
+const DEFAULT_LIST_OPTIONS = {
+    pageSize: DEFAULT_PAGE_SIZE,
     delimiter: '/',
     exclude: 'FILE',
 };
-const DEFAULT_REFRESH_OPTIONS = { ...DEFAULT_LIST_OPTIONS$2, refresh: true };
+const DEFAULT_REFRESH_OPTIONS = { ...DEFAULT_LIST_OPTIONS, refresh: true };
 const useFolders = ({ destination, setDestination, }) => {
     const { current, key } = destination;
     const [{ value, hasError, isLoading, message }, handleList] = useList('folderItems');
@@ -5009,19 +5476,19 @@ const useFolders = ({ destination, setDestination, }) => {
             return;
         handleList({
             prefix: key,
-            options: { ...DEFAULT_LIST_OPTIONS$2, nextToken },
+            options: { ...DEFAULT_LIST_OPTIONS, nextToken },
         });
     };
     const { currentPage: page, handlePaginate, highestPageVisited, pageItems, handleReset, } = usePaginate({
         items,
         onPaginate,
-        pageSize: DEFAULT_PAGE_SIZE$2,
+        pageSize: DEFAULT_PAGE_SIZE,
     });
     const onSearch = (query) => {
         handleReset();
         handleList({
             prefix: key,
-            options: { ...DEFAULT_LIST_OPTIONS$2, search: { query, filterBy: 'key' } },
+            options: { ...DEFAULT_LIST_OPTIONS, search: { query, filterBy: 'key' } },
         });
     };
     const { onSearchSubmit, searchQuery: query, resetSearch, onSearchQueryChange: onQuery, } = useSearch({ onSearch });
@@ -5184,12 +5651,12 @@ 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, statusCounts, tasks: items, onActionCancel, onActionStart, onActionExit, onTaskRemove, } = props;
+    const { isProcessing, isProcessingComplete, statusCounts, tasks, confirmationModal, onActionCancel, onActionStart, onActionExit, onTaskRemove, onConfirmDelete, onCancelConfirmation, } = props;
     const message = isProcessingComplete
-        ? getActionCompleteMessage({ counts: statusCounts })
+        ? getActionCompleteMessage({ counts: statusCounts, tasks })
         : undefined;
-    const tableData = useResolveTableData(FILE_DATA_ITEM_TABLE_KEYS, DELETE_TABLE_RESOLVERS, {
-        items,
+    const tableData = useResolveTableData(DELETE_TABLE_KEYS, DELETE_TABLE_RESOLVERS, {
+        items: tasks,
         props: { displayText, isProcessing, onTaskRemove },
     });
     return (React__namespace["default"].createElement(ControlsContextProvider, { data: {
@@ -5207,24 +5674,80 @@ function DeleteViewProvider({ children, ...props }) {
             tableData,
             title,
             message,
-        }, onActionStart: onActionStart, onActionExit: onActionExit, onActionCancel: onActionCancel }, children));
+            confirmationModal,
+        }, onActionStart: onActionStart, onActionExit: onActionExit, onActionCancel: onActionCancel, onConfirmationModalConfirm: onConfirmDelete, onConfirmationModalCancel: onCancelConfirmation }, children));
 }
 
 // assign to constant to ensure referential equality
 const EMPTY_ITEMS$1 = [];
 const useDeleteView = (options) => {
     const { onExit: _onExit } = options ?? {};
+    const { DeleteView: displayText } = useDisplayText();
     const [{ location }, storeDispatch] = useStore();
     const [locationItems, locationItemsDispatch] = useLocationItems();
     const { current } = location;
-    const { fileDataItems: items = EMPTY_ITEMS$1 } = locationItems;
-    const [processState, handleProcess] = useAction('delete', { items });
+    const { dataItems = EMPTY_ITEMS$1 } = locationItems;
+    const getConfig = useGetActionInput();
+    const [itemsWithCount, setItemsWithCount] = React__namespace["default"].useState(dataItems);
+    const folderCountsRef = React__namespace["default"].useRef(new Map());
+    // Sync itemsWithCount with dataItems when dataItems changes (e.g., item removal)
+    React__namespace["default"].useEffect(() => {
+        const itemsWithAppliedCounts = dataItems.map((item) => ({
+            ...item,
+            totalCount: folderCountsRef.current.get(item.id),
+        }));
+        setItemsWithCount(itemsWithAppliedCounts);
+    }, [dataItems]);
+    const [processState, handleProcess] = useAction('delete', {
+        items: itemsWithCount,
+    });
+    const [showConfirmation, setShowConfirmation] = React__namespace["default"].useState(false);
     const { isProcessing, isProcessingComplete, statusCounts, tasks } = processState;
+    const selectionSummary = getSelectionSummary(dataItems);
+    const { hasFolders } = selectionSummary;
+    React__namespace["default"].useEffect(() => {
+        const initializeFolderCounts = async () => {
+            if (!selectionSummary.hasFolders || !current) {
+                return;
+            }
+            const config = getConfig(current);
+            const foldersToCount = dataItems.filter((item) => item.type === 'FOLDER' && !folderCountsRef.current.has(item.id));
+            if (foldersToCount.length === 0) {
+                return;
+            }
+            await Promise.all(foldersToCount.map(async (folder) => {
+                try {
+                    const totalCount = await countFilesInFolder(folder.key, config);
+                    folderCountsRef.current.set(folder.id, totalCount);
+                }
+                catch (error) {
+                    folderCountsRef.current.set(folder.id, null);
+                }
+            }));
+            setItemsWithCount((currentItems) => currentItems.map((item) => ({
+                ...item,
+                totalCount: folderCountsRef.current.get(item.id),
+            })));
+        };
+        initializeFolderCounts();
+    }, [current, getConfig, selectionSummary.hasFolders, dataItems]);
     const onActionStart = () => {
         if (!current)
             return;
+        if (hasFolders) {
+            setShowConfirmation(true);
+        }
+        else {
+            handleProcess();
+        }
+    };
+    const onConfirmDelete = () => {
+        setShowConfirmation(false);
         handleProcess();
     };
+    const onCancelConfirmation = () => {
+        setShowConfirmation(false);
+    };
     const onActionCancel = () => {
         tasks.forEach((task) => {
             // @TODO Fixme, calling cancel on task doesn't currently work
@@ -5243,6 +5766,11 @@ const useDeleteView = (options) => {
     const onTaskRemove = React__namespace["default"].useCallback(({ data }) => {
         locationItemsDispatch({ type: 'REMOVE_LOCATION_ITEM', id: data.id });
     }, [locationItemsDispatch]);
+    const confirmationModal = React__namespace["default"].useMemo(() => createDeleteConfirmationModalProps({
+        items: dataItems,
+        showConfirmation,
+        displayText,
+    }), [dataItems, showConfirmation, displayText]);
     return {
         isProcessing,
         isProcessingComplete,
@@ -5253,6 +5781,9 @@ const useDeleteView = (options) => {
         onActionExit,
         onActionStart,
         onTaskRemove,
+        onConfirmDelete,
+        onCancelConfirmation,
+        confirmationModal,
     };
 };
 
@@ -5271,11 +5802,13 @@ const DeleteView = ({ className, ...props }) => {
                     React__namespace["default"].createElement(MessageControl, null)),
                 React__namespace["default"].createElement(ViewElement, { className: `${STORAGE_BROWSER_BLOCK}__buttons` },
                     React__namespace["default"].createElement(ActionCancelControl, null),
-                    React__namespace["default"].createElement(ActionStartControl, null))))));
+                    React__namespace["default"].createElement(ActionStartControl, null))),
+            React__namespace["default"].createElement(ActionConfirmationModalControl, null))));
 };
 DeleteView.displayName = 'DeleteView';
 DeleteView.Provider = DeleteViewProvider;
 DeleteView.Cancel = ActionCancelControl;
+DeleteView.ConfirmationModal = ActionConfirmationModalControl;
 DeleteView.Exit = ActionExitControl;
 DeleteView.Message = MessageControl;
 DeleteView.Start = ActionStartControl;
@@ -5489,34 +6022,45 @@ const getFileRowContent = ({ filePreviewEnabled, permissions, isSelected, itemLo
     }
 });
 
-const getFolderRowContent = ({ itemSubPath, rowId, onNavigate, }) => LOCATION_DETAIL_VIEW_HEADERS.map((columnKey) => {
-    const key = `${columnKey}-${rowId}`;
-    switch (columnKey) {
-        case 'checkbox': {
-            return { key, type: 'text', content: { text: '' } };
-        }
-        case 'name': {
-            return {
-                key,
-                type: 'button',
-                content: {
-                    icon: 'folder',
-                    ariaLabel: itemSubPath,
-                    label: itemSubPath,
-                    onClick: onNavigate,
-                },
-            };
-        }
-        case 'type': {
-            return { key, type: 'text', content: { text: 'Folder' } };
-        }
-        case 'last-modified':
-        case 'size':
-        case 'download': {
-            return { key, type: 'text', content: { text: '' } };
+const getFolderRowContent = ({ itemSubPath, rowId, isSelected, selectFolderLabel, onNavigate, onSelect, }) => {
+    return LOCATION_DETAIL_VIEW_HEADERS.map((columnKey) => {
+        const key = `${columnKey}-${rowId}`;
+        switch (columnKey) {
+            case 'checkbox': {
+                return {
+                    key,
+                    type: 'checkbox',
+                    content: {
+                        checked: isSelected,
+                        id: key,
+                        label: `${selectFolderLabel} ${itemSubPath}`,
+                        onSelect,
+                    },
+                };
+            }
+            case 'name': {
+                return {
+                    key,
+                    type: 'button',
+                    content: {
+                        icon: 'folder',
+                        ariaLabel: itemSubPath,
+                        label: itemSubPath,
+                        onClick: onNavigate,
+                    },
+                };
+            }
+            case 'type': {
+                return { key, type: 'text', content: { text: 'Folder' } };
+            }
+            case 'last-modified':
+            case 'size':
+            case 'download': {
+                return { key, type: 'text', content: { text: '' } };
+            }
         }
-    }
-});
+    });
+};
 
 const getHeaders$1 = ({ tableColumnLastModifiedHeader, tableColumnNameHeader, tableColumnSizeHeader, tableColumnTypeHeader, areAllFilesSelected, selectAllFilesLabel, onSelectAll, hasFiles, }) => LOCATION_DETAIL_VIEW_HEADERS.map((key) => {
     switch (key) {
@@ -5583,7 +6127,7 @@ const getHeaders$1 = ({ tableColumnLastModifiedHeader, tableColumnNameHeader, ta
     }
 });
 
-const getLocationDetailViewTableData = ({ filePreviewEnabled, activeFile, onSelectActiveFile, areAllFilesSelected, displayText, location, fileDataItems, hasFiles, pageItems, selectFileLabel, selectAllFilesLabel, getDateDisplayValue, onDownload, onNavigate, onSelect, onSelectAll, }) => {
+const getLocationDetailViewTableData = ({ filePreviewEnabled, activeFile, onSelectActiveFile, areAllFilesSelected, displayText, location, fileDataItems, dataItems, hasFiles, pageItems, selectFileLabel, selectAllFilesLabel, getDateDisplayValue, onDownload, onNavigate, onSelect, onSelectAll, }) => {
     const { tableColumnLastModifiedHeader, tableColumnNameHeader, tableColumnSizeHeader, tableColumnTypeHeader, } = displayText;
     const headers = getHeaders$1({
         areAllFilesSelected,
@@ -5641,6 +6185,10 @@ const getLocationDetailViewTableData = ({ filePreviewEnabled, activeFile, onSele
                     }
                     onNavigate({ ...current, id }, itemLocationPath);
                 };
+                const isSelected = dataItems?.some((item) => item.id === id) ?? false;
+                const onFolderSelect = () => {
+                    onSelect(isSelected, locationItem);
+                };
                 return {
                     key: id,
                     active: false,
@@ -5648,6 +6196,9 @@ const getLocationDetailViewTableData = ({ filePreviewEnabled, activeFile, onSele
                         itemSubPath,
                         rowId: id,
                         onNavigate: onFolderNavigate,
+                        selectFolderLabel: selectFileLabel,
+                        isSelected,
+                        onSelect: onFolderSelect,
                     }),
                 };
             }
@@ -5659,7 +6210,7 @@ const getLocationDetailViewTableData = ({ filePreviewEnabled, activeFile, onSele
 function LocationDetailViewProvider({ children, ...props }) {
     const { LocationDetailView: displayText } = useDisplayText();
     const { LocationDetailView: { loadingIndicatorLabel, searchSubfoldersToggleLabel, selectFileLabel, selectAllFilesLabel, searchPlaceholder, searchSubmitLabel, searchClearLabel, getActionListItemLabel, getDateDisplayValue, getTitle, getListItemsResultMessage, }, } = useDisplayText();
-    const { actionItems, activeFile, activeFileHasNext, activeFileHasPrev, page, pageItems, hasNextPage, highestPageVisited, isLoading, isSearchSubfoldersEnabled, location, fileDataItems, hasError, hasDownloadError, message, downloadErrorMessage, searchQuery, hasExhaustedSearch, onActionSelect, onDropFiles, onRefresh, onPaginate, onDownload, onNavigate, onNavigateHome, onSelect, onSelectActiveFile, onToggleSelectAll, onSearch, onSearchQueryChange, onSearchClear, onToggleSearchSubfolders, filePreviewState, filePreviewEnabled, onRetryFilePreview, } = props;
+    const { actionItems, activeFile, activeFileHasNext, activeFileHasPrev, page, pageItems, hasNextPage, highestPageVisited, isLoading, isSearchSubfoldersEnabled, location, fileDataItems, hasError, hasDownloadError, message, downloadErrorMessage, searchQuery, hasExhaustedSearch, onActionSelect, onDropFiles, onRefresh, onPaginate, onDownload, onNavigate, onNavigateHome, onSelect, onSelectActiveFile, onToggleSelectAll, onSearch, onSearchQueryChange, onSearchClear, onToggleSearchSubfolders, filePreviewState, filePreviewEnabled, onRetryFilePreview, dataItems, } = props;
     const actionsWithDisplayText = actionItems.map((item) => ({
         ...item,
         label: getActionListItemLabel(item.label),
@@ -5716,6 +6267,7 @@ function LocationDetailViewProvider({ children, ...props }) {
                 onNavigate,
                 onSelect,
                 onSelectAll: onToggleSelectAll,
+                dataItems,
             }),
             title: getTitle(location),
             message: messageControlContent,
@@ -5865,30 +6417,29 @@ function useFilePreview({ activeFile, }) {
     }, [getFilePreview, filePreviewContext, filePreviewContent, enabled]);
 }
 
-const DEFAULT_PAGE_SIZE$1 = 100;
-const DEFAULT_LIST_OPTIONS$1 = {
-    delimiter: '/',
-    pageSize: DEFAULT_PAGE_SIZE$1,
-};
 const getDownloadErrorMessageFromFailedDownloadTask = (task) => {
     if (!task)
         return;
     return `Failed to download ${task.data.fileKey ?? task.data.key} due to error: ${task.message}.`;
 };
 const useLocationDetailView = (options) => {
-    const { initialValues, onExit, onNavigate } = options ?? {};
-    const listOptionsRef = React__namespace["default"].useRef({
-        ...DEFAULT_LIST_OPTIONS$1,
+    const { pageSize: configPageSize } = usePaginationConfig();
+    const { initialValues = {}, onExit, onNavigate, pageSize: propPageSize, } = options ?? {};
+    const pageSize = propPageSize ?? configPageSize;
+    const listOptions = React__namespace["default"].useMemo(() => ({
         ...initialValues,
-    });
-    const listOptions = listOptionsRef.current;
+        delimiter: '/',
+        pageSize,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [pageSize, initialValues.delimiter, initialValues.pageSize]);
     const [{ location, actionType }, storeDispatch] = useStore();
     const [locationItems, locationItemsDispatch] = useLocationItems();
     const fileItemsDispatch = useFileItems()[1];
     const [activeFile, setActiveFile] = React__namespace["default"].useState();
     const { current, key } = location;
     const { permissions, prefix } = current ?? {};
-    const { fileDataItems } = locationItems;
+    const { dataItems, fileDataItems } = locationItems;
     const hasInvalidPrefix = ui.isUndefined(prefix);
     const [{ task }, handleDownload] = useAction('download');
     const [{ value, isLoading, hasError, message }, handleList] = useList('locationItems');
@@ -6015,13 +6566,13 @@ const useLocationDetailView = (options) => {
                     actionType: type,
                     icon,
                     isDisabled: ui.isFunction(disable)
-                        ? disable(fileDataItems)
+                        ? disable(dataItems)
                         : disable ?? false,
                     isHidden: ui.isFunction(hide) ? hide(permissions) : hide,
                     label,
                 };
             });
-    }, [actionConfigs, fileDataItems, permissions]);
+    }, [actionConfigs, dataItems, permissions]);
     return {
         actionItems,
         actionType,
@@ -6032,6 +6583,7 @@ const useLocationDetailView = (options) => {
         page: currentPage,
         pageItems,
         location,
+        dataItems,
         fileDataItems,
         hasError,
         hasDownloadError: task?.status === 'FAILED',
@@ -6087,16 +6639,16 @@ const useLocationDetailView = (options) => {
             storeDispatch({ type: 'RESET_ACTION_TYPE' });
             locationItemsDispatch({ type: 'RESET_LOCATION_ITEMS' });
         },
-        onSelect: (isSelected, fileItem) => {
+        onSelect: (isSelected, item) => {
             locationItemsDispatch(isSelected
-                ? { type: 'REMOVE_LOCATION_ITEM', id: fileItem.id }
-                : { type: 'SET_LOCATION_ITEMS', items: [fileItem] });
+                ? { type: 'REMOVE_LOCATION_ITEM', id: item.id }
+                : { type: 'SET_LOCATION_ITEMS', items: [item] });
         },
         onToggleSelectAll: () => {
-            const fileItems = pageItems.filter((item) => item.type === 'FILE');
-            locationItemsDispatch(fileItems.length === fileDataItems?.length
+            const selectableItems = pageItems;
+            locationItemsDispatch(selectableItems.length === dataItems?.length
                 ? { type: 'RESET_LOCATION_ITEMS' }
-                : { type: 'SET_LOCATION_ITEMS', items: fileItems });
+                : { type: 'SET_LOCATION_ITEMS', items: selectableItems });
         },
         onSearch: () => {
             setActiveFile(undefined);
@@ -6310,12 +6862,8 @@ function LocationsViewProvider({ children, ...props }) {
 const DEFAULT_EXCLUDE = {
     exactPermissions: ['delete', 'write'],
 };
-const DEFAULT_PAGE_SIZE = 100;
-const DEFAULT_LIST_OPTIONS = {
-    exclude: DEFAULT_EXCLUDE,
-    pageSize: DEFAULT_PAGE_SIZE,
-};
 const useLocationsView = (options) => {
+    const { pageSize: configPageSize } = usePaginationConfig();
     const handleDownload = useAction('download')[1];
     const [state, handleList] = useList('locations');
     const dispatchStoreAction = useStore()[1];
@@ -6323,12 +6871,15 @@ const useLocationsView = (options) => {
     const { items, nextToken, hasExhaustedSearch = false } = value;
     const hasNextToken = !!nextToken;
     const onNavigate = options?.onNavigate;
+    const pageSize = options?.pageSize ?? configPageSize;
     const initialValues = options?.initialValues ?? {};
-    const listOptionsRef = React__namespace["default"].useRef({
-        ...DEFAULT_LIST_OPTIONS,
+    const listOptions = React__namespace["default"].useMemo(() => ({
         ...initialValues,
-    });
-    const listOptions = listOptionsRef.current;
+        exclude: DEFAULT_EXCLUDE,
+        pageSize,
+    }), 
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [pageSize, initialValues.pageSize]);
     // initial load
     React__namespace["default"].useEffect(() => {
         handleList({ options: { ...listOptions, refresh: true } });
@@ -6532,17 +7083,18 @@ function createProvider({ actions, components, config, options, filePreview = {}
      * Provides state, configuration and action values that are shared between
      * the primary View components
      */
-    function Provider({ children, displayText, views, ...props }) {
+    function Provider({ children, displayText, views, pageSize, ...props }) {
         return (React__namespace["default"].createElement(StoreProvider, { ...props },
             React__namespace["default"].createElement(ConfigurationProvider, null,
-                React__namespace["default"].createElement(ActionConfigsProvider, { actionConfigs: actionConfigs },
-                    React__namespace["default"].createElement(ActionHandlersProvider, { handlers: handlers },
-                        React__namespace["default"].createElement(DisplayTextProvider, { displayText: displayText },
-                            React__namespace["default"].createElement(ViewsProvider, { actions: resolvedActions, views: views },
-                                React__namespace["default"].createElement(ComponentsProvider, { composables: composables },
-                                    React__namespace["default"].createElement(LocationItemsProvider, null,
-                                        React__namespace["default"].createElement(FileItemsProvider, { validateFile: validateFile },
-                                            React__namespace["default"].createElement(FilePreviewProvider, { filePreview: filePreview }, children)))))))))));
+                React__namespace["default"].createElement(PaginationConfigProvider, { pageSize: pageSize },
+                    React__namespace["default"].createElement(ActionConfigsProvider, { actionConfigs: actionConfigs },
+                        React__namespace["default"].createElement(ActionHandlersProvider, { handlers: handlers },
+                            React__namespace["default"].createElement(DisplayTextProvider, { displayText: displayText },
+                                React__namespace["default"].createElement(ViewsProvider, { actions: resolvedActions, views: views },
+                                    React__namespace["default"].createElement(ComponentsProvider, { composables: composables },
+                                        React__namespace["default"].createElement(LocationItemsProvider, null,
+                                            React__namespace["default"].createElement(FileItemsProvider, { validateFile: validateFile },
+                                                React__namespace["default"].createElement(FilePreviewProvider, { filePreview: filePreview }, children))))))))))));
     }
     return Provider;
 }