@aws-amplify/ui-react-storage 3.3.9 → 3.4.0

package/dist/esm/components/StorageBrowser/views/LocationActionView/UploadView/useUploadView.mjs

@@ -0,0 +1,101 @@
+import React__default from 'react';
+import '../../../actions/configs/context.mjs';
+import '@aws-amplify/storage/internals';
+import { isUndefined } from '@aws-amplify/ui';
+import { isFileTooBig } from '../../../validators/isFileTooBig.mjs';
+import { uploadHandler } from '../../../actions/handlers/upload.mjs';
+import '@aws-amplify/ui-react-core';
+import { useGetActionInput } from '../../../providers/configuration/context.mjs';
+import '@aws-amplify/ui-react-core/elements';
+import '../../../providers/configuration/credentials/context.mjs';
+import '../../../providers/store/location/context.mjs';
+import '../../../providers/store/files/context.mjs';
+import '../../../providers/store/actionType/context.mjs';
+import '../../../providers/store/locationItems/context.mjs';
+import { useStore } from '../../../providers/store/useStore.mjs';
+import { useProcessTasks } from '../../../tasks/useProcessTasks.mjs';
+import { DEFAULT_ACTION_CONCURRENCY } from '../constants.mjs';
+import { DEFAULT_OVERWRITE_ENABLED } from './constants.mjs';
+
+const useUploadView = (options) => {
+    const { onExit: _onExit } = options ?? {};
+    const getInput = useGetActionInput();
+    const [{ files, location }, dispatchStoreAction] = useStore();
+    const { current, key } = location;
+    const { invalidFiles, validFiles } = React__default.useMemo(() => (files ?? [])?.reduce((curr, file) => {
+        if (isFileTooBig(file.file)) {
+            curr.invalidFiles = isUndefined(curr.invalidFiles)
+                ? [file]
+                : curr.invalidFiles.concat(file);
+        }
+        else {
+            curr.validFiles = isUndefined(curr.validFiles)
+                ? [file]
+                : curr.validFiles.concat(file);
+        }
+        return curr;
+    }, {}), [files]);
+    const [isOverwritingEnabled, setIsOverwritingEnabled] = React__default.useState(DEFAULT_OVERWRITE_ENABLED);
+    const [{ isProcessing, isProcessingComplete, statusCounts, tasks }, handleProcess,] = useProcessTasks(uploadHandler, validFiles, {
+        concurrency: DEFAULT_ACTION_CONCURRENCY,
+    });
+    const onDropFiles = React__default.useCallback((files) => {
+        if (files) {
+            dispatchStoreAction({ type: 'ADD_FILE_ITEMS', files });
+        }
+    }, [dispatchStoreAction]);
+    const onSelectFiles = React__default.useCallback((type) => {
+        dispatchStoreAction({ type: 'SELECT_FILES', selectionType: type });
+    }, [dispatchStoreAction]);
+    const onActionStart = React__default.useCallback(() => {
+        invalidFiles?.forEach((file) => {
+            dispatchStoreAction({ type: 'REMOVE_FILE_ITEM', id: file.id });
+        });
+        handleProcess({
+            config: getInput(),
+            destinationPrefix: key,
+            options: { preventOverwrite: !isOverwritingEnabled },
+        });
+    }, [
+        isOverwritingEnabled,
+        key,
+        getInput,
+        handleProcess,
+        invalidFiles,
+        dispatchStoreAction,
+    ]);
+    const onActionCancel = React__default.useCallback(() => {
+        tasks.forEach((task) => task.cancel?.());
+    }, [tasks]);
+    const onActionExit = React__default.useCallback(() => {
+        // clear files state
+        dispatchStoreAction({ type: 'RESET_FILE_ITEMS' });
+        // clear selected action
+        dispatchStoreAction({ type: 'RESET_ACTION_TYPE' });
+        _onExit?.(current);
+    }, [dispatchStoreAction, _onExit, current]);
+    const onToggleOverwrite = React__default.useCallback(() => {
+        setIsOverwritingEnabled((prev) => !prev);
+    }, []);
+    const onTaskRemove = React__default.useCallback(({ data }) => {
+        dispatchStoreAction({ type: 'REMOVE_FILE_ITEM', id: data.id });
+    }, [dispatchStoreAction]);
+    return {
+        isProcessing,
+        isProcessingComplete,
+        isOverwritingEnabled,
+        location,
+        invalidFiles,
+        statusCounts,
+        tasks,
+        onActionCancel,
+        onActionExit,
+        onActionStart,
+        onDropFiles,
+        onTaskRemove,
+        onSelectFiles,
+        onToggleOverwrite,
+    };
+};
+
+export { useUploadView };

package/dist/esm/components/StorageBrowser/views/LocationActionView/constants.mjs

@@ -0,0 +1,3 @@
+const DEFAULT_ACTION_CONCURRENCY = 4;
+
+export { DEFAULT_ACTION_CONCURRENCY };

package/dist/esm/components/StorageBrowser/views/LocationActionView/getActionIcon.mjs

@@ -0,0 +1,25 @@
+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';
+        }
+    }
+};
+
+export { getActionIcon };

package/dist/esm/components/StorageBrowser/views/LocationActionView/getActionViewTableData.mjs

@@ -0,0 +1,155 @@
+import { humanFileSize } from '@aws-amplify/ui';
+import '../../actions/configs/context.mjs';
+import '@aws-amplify/storage/internals';
+import { isFileDataItem, isFileItem } from '../../actions/handlers/utils.mjs';
+import 'aws-amplify/storage';
+import 'react';
+import '@aws-amplify/ui-react-core';
+import { getActionIcon } from './getActionIcon.mjs';
+import { getFileTypeDisplayValue } from './getFileTypeDisplayValue.mjs';
+import { getPercentValue } from './getPercentValue.mjs';
+import { getDefaultActionViewHeaders } from './getDefaultActionViewHeaders.mjs';
+
+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 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));
+    }
+    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 ? 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(progress ?? 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: {} };
+                }
+            }),
+        };
+    });
+    return { headers, rows };
+};
+
+export { getActionViewTableData, getProgressHeader };

package/dist/esm/components/StorageBrowser/views/LocationActionView/getDefaultActionViewHeaders.mjs

@@ -0,0 +1,24 @@
+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 } },
+    ];
+};
+
+export { getDefaultActionViewHeaders };

package/dist/esm/components/StorageBrowser/views/LocationActionView/getFileTypeDisplayValue.mjs

@@ -0,0 +1,5 @@
+const getFileTypeDisplayValue = (fileName) => fileName.lastIndexOf('.') !== -1
+    ? fileName.slice(fileName.lastIndexOf('.') + 1)
+    : '';
+
+export { getFileTypeDisplayValue };

package/dist/esm/components/StorageBrowser/views/LocationActionView/getPercentValue.mjs

@@ -0,0 +1,3 @@
+const getPercentValue = (value) => Math.round(value * 100);
+
+export { getPercentValue };

package/dist/esm/components/StorageBrowser/views/LocationActionView/useActionView.mjs

@@ -0,0 +1,20 @@
+import { INITIAL_STATUS_COUNTS } from '../../tasks/constants.mjs';
+import 'react';
+import '@aws-amplify/ui';
+import { DEFAULT_STATE } from '../../providers/store/location/context.mjs';
+
+function useActionView() {
+    return {
+        isProcessing: false,
+        isProcessingComplete: false,
+        location: DEFAULT_STATE,
+        statusCounts: INITIAL_STATUS_COUNTS,
+        tasks: [],
+        onActionExit: () => null,
+        onActionStart: () => null,
+        onActionCancel: () => null,
+        onTaskRemove: () => null,
+    };
+}
+
+export { useActionView };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/LocationDetailView.mjs

@@ -0,0 +1,56 @@
+import React__default from 'react';
+import { STORAGE_BROWSER_BLOCK } from '../../constants.mjs';
+import '@aws-amplify/ui-react';
+import { ViewElement } from '../../context/elements/definitions.mjs';
+import '../../context/elements/IconElement.mjs';
+import { ActionsListControl } from '../../controls/ActionsListControl.mjs';
+import { DataTableControl } from '../../controls/DataTableControl.mjs';
+import { DataRefreshControl } from '../../controls/DataRefreshControl.mjs';
+import { DropZoneControl } from '../../controls/DropZoneControl.mjs';
+import { LoadingIndicatorControl } from '../../controls/LoadingIndicatorControl.mjs';
+import { MessageControl } from '../../controls/MessageControl.mjs';
+import { NavigationControl } from '../../controls/NavigationControl.mjs';
+import { PaginationControl } from '../../controls/PaginationControl.mjs';
+import { SearchControl } from '../../controls/SearchControl.mjs';
+import { SearchSubfoldersToggleControl } from '../../controls/SearchSubfoldersToggleControl.mjs';
+import { TitleControl } from '../../controls/TitleControl.mjs';
+import { useLocationDetailView } from './useLocationDetailView.mjs';
+import { LocationDetailViewProvider } from './LocationDetailViewProvider.mjs';
+import { classNames } from '@aws-amplify/ui';
+
+const LocationDetailView = ({ className, ...props }) => {
+    const state = useLocationDetailView(props);
+    const { hasError } = state;
+    return (React__default.createElement(ViewElement, { className: classNames(STORAGE_BROWSER_BLOCK, className), "data-testid": "LOCATION_DETAIL_VIEW" },
+        React__default.createElement(LocationDetailViewProvider, { ...state },
+            React__default.createElement(NavigationControl, null),
+            React__default.createElement(TitleControl, null),
+            React__default.createElement(ViewElement, { className: `${STORAGE_BROWSER_BLOCK}__controls` },
+                React__default.createElement(ViewElement, { className: `${STORAGE_BROWSER_BLOCK}__search` },
+                    React__default.createElement(SearchControl, null),
+                    React__default.createElement(SearchSubfoldersToggleControl, null)),
+                React__default.createElement(PaginationControl, null),
+                React__default.createElement(DataRefreshControl, null),
+                React__default.createElement(ActionsListControl, null)),
+            hasError ? null : (React__default.createElement(DropZoneControl, null,
+                React__default.createElement(ViewElement, { className: `${STORAGE_BROWSER_BLOCK}__data-table` },
+                    React__default.createElement(LoadingIndicatorControl, null),
+                    React__default.createElement(DataTableControl, null)))),
+            React__default.createElement(ViewElement, { className: `${STORAGE_BROWSER_BLOCK}__footer` },
+                React__default.createElement(MessageControl, null)))));
+};
+LocationDetailView.displayName = 'LocationDetailView';
+LocationDetailView.Provider = LocationDetailViewProvider;
+LocationDetailView.ActionsList = ActionsListControl;
+LocationDetailView.DropZone = DropZoneControl;
+LocationDetailView.LoadingIndicator = LoadingIndicatorControl;
+LocationDetailView.LocationItemsTable = DataTableControl;
+LocationDetailView.Message = MessageControl;
+LocationDetailView.Navigation = NavigationControl;
+LocationDetailView.Pagination = PaginationControl;
+LocationDetailView.Refresh = DataRefreshControl;
+LocationDetailView.Search = SearchControl;
+LocationDetailView.SearchSubfoldersToggle = SearchSubfoldersToggleControl;
+LocationDetailView.Title = TitleControl;
+
+export { LocationDetailView };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/LocationDetailViewProvider.mjs

@@ -0,0 +1,60 @@
+import React__default from 'react';
+import { ControlsContextProvider } from '../../controls/context.mjs';
+import { useDisplayText } from '../../displayText/context.mjs';
+import '@aws-amplify/ui';
+import { getLocationDetailViewTableData } from './getLocationDetailViewTableData/getLocationDetailViewTableData.mjs';
+
+function LocationDetailViewProvider({ children, ...props }) {
+    const { LocationDetailView: { loadingIndicatorLabel, searchSubfoldersToggleLabel, selectFileLabel, selectAllFilesLabel, searchPlaceholder, searchSubmitLabel, searchClearLabel, getActionListItemLabel, getDateDisplayValue, getTitle, getListItemsResultMessage, }, } = useDisplayText();
+    const { actions, page, pageItems, hasNextPage, highestPageVisited, isLoading, isSearchingSubfolders, location, areAllFilesSelected, fileDataItems, hasFiles, hasError, hasDownloadError, message, downloadErrorMessage, searchQuery, hasExhaustedSearch, onActionSelect, onDropFiles, onRefresh, onPaginate, onDownload, onNavigate, onNavigateHome, onSelect, onSelectAll, onSearch, onSearchQueryChange, onSearchClear, onToggleSearchSubfolders, } = props;
+    const actionsWithDisplayText = actions.map((item) => ({
+        ...item,
+        label: getActionListItemLabel(item.label),
+    }));
+    const messageControlContent = getListItemsResultMessage({
+        isLoading,
+        items: pageItems,
+        hasError: hasError || hasDownloadError,
+        hasExhaustedSearch,
+        message: hasError ? message : downloadErrorMessage,
+    });
+    const isNoActionAvailable = !Array.isArray(actions) || actions?.every((action) => action.isHidden);
+    return (React__default.createElement(ControlsContextProvider, { data: {
+            actions: actionsWithDisplayText,
+            isActionsListDisabled: isLoading || isNoActionAvailable,
+            isDataRefreshDisabled: isLoading,
+            isLoading,
+            isSearchingSubfolders,
+            loadingIndicatorLabel,
+            location,
+            paginationData: {
+                page,
+                hasNextPage,
+                highestPageVisited,
+                onPaginate,
+            },
+            searchPlaceholder,
+            searchSubfoldersToggleLabel,
+            searchSubmitLabel,
+            searchClearLabel,
+            searchQuery,
+            tableData: getLocationDetailViewTableData({
+                areAllFilesSelected,
+                location,
+                fileDataItems,
+                getDateDisplayValue,
+                hasFiles,
+                pageItems,
+                selectFileLabel,
+                selectAllFilesLabel,
+                onDownload,
+                onNavigate,
+                onSelect,
+                onSelectAll,
+            }),
+            title: getTitle(location),
+            message: messageControlContent,
+        }, onActionSelect: onActionSelect, onDropFiles: onDropFiles, onNavigate: onNavigate, onNavigateHome: onNavigateHome, onRefresh: onRefresh, onSearch: onSearch, onSearchQueryChange: onSearchQueryChange, onSearchClear: onSearchClear, onToggleSearchSubfolders: onToggleSearchSubfolders }, children));
+}
+
+export { LocationDetailViewProvider };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/getLocationDetailViewTableData/constants.mjs

@@ -0,0 +1,10 @@
+const LOCATION_DETAIL_VIEW_HEADERS = [
+    { key: 'checkbox', type: 'text', content: { text: '' } },
+    { key: 'name', type: 'sort', content: { label: 'Name' } },
+    { key: 'type', type: 'sort', content: { label: 'Type' } },
+    { key: 'last-modified', type: 'sort', content: { label: 'Last modified' } },
+    { key: 'size', type: 'sort', content: { label: 'Size' } },
+    { key: 'download', type: 'text', content: { text: '' } },
+];
+
+export { LOCATION_DETAIL_VIEW_HEADERS };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/getLocationDetailViewTableData/getFileRowContent.mjs

@@ -0,0 +1,76 @@
+import { humanFileSize } from '@aws-amplify/ui';
+import { LOCATION_DETAIL_VIEW_HEADERS } from './constants.mjs';
+
+const getFileRowContent = ({ permissions, isSelected, itemLocationKey, getDateDisplayValue, lastModified, rowId, rowKey, selectFileLabel, size, onDownload, onSelect, }) => LOCATION_DETAIL_VIEW_HEADERS.map(({ key: columnKey }) => {
+    const key = `${columnKey}-${rowId}`;
+    switch (columnKey) {
+        case 'checkbox': {
+            return {
+                key,
+                type: 'checkbox',
+                content: {
+                    checked: isSelected,
+                    id: key,
+                    label: `${selectFileLabel} ${rowKey}`,
+                    onSelect,
+                },
+            };
+        }
+        case 'name': {
+            return {
+                key,
+                type: 'text',
+                content: {
+                    icon: 'file',
+                    ariaLabel: 'file',
+                    text: rowKey.slice(itemLocationKey.length),
+                },
+            };
+        }
+        case 'type': {
+            const splitKey = rowKey.split('.');
+            return {
+                key,
+                type: 'text',
+                content: {
+                    text: `${splitKey.length > 1 && splitKey[0] ? splitKey.pop() : '-'}`,
+                },
+            };
+        }
+        case 'last-modified': {
+            return {
+                key,
+                type: 'date',
+                content: {
+                    value: lastModified,
+                    displayValue: getDateDisplayValue(lastModified),
+                },
+            };
+        }
+        case 'size': {
+            return {
+                key,
+                type: 'number',
+                content: {
+                    value: size,
+                    displayValue: humanFileSize(size, true),
+                },
+            };
+        }
+        case 'download': {
+            return permissions.includes('get')
+                ? {
+                    key,
+                    type: 'button',
+                    content: {
+                        icon: 'download',
+                        onClick: onDownload,
+                        ariaLabel: 'download',
+                    },
+                }
+                : { key, type: 'text', content: { text: '' } };
+        }
+    }
+});
+
+export { getFileRowContent };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/getLocationDetailViewTableData/getFolderRowContent.mjs

@@ -0,0 +1,32 @@
+import { LOCATION_DETAIL_VIEW_HEADERS } from './constants.mjs';
+
+const getFolderRowContent = ({ itemSubPath, rowId, onNavigate, }) => LOCATION_DETAIL_VIEW_HEADERS.map(({ key: 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: '' } };
+        }
+    }
+});
+
+export { getFolderRowContent };

package/dist/esm/components/StorageBrowser/views/LocationDetailView/getLocationDetailViewTableData/getLocationDetailViewTableData.mjs

@@ -0,0 +1,77 @@
+import '@aws-amplify/storage/internals';
+import { createFileDataItem } from '../../../actions/handlers/utils.mjs';
+import '@aws-amplify/ui';
+import 'aws-amplify/storage';
+import { getFileRowContent } from './getFileRowContent.mjs';
+import { getFolderRowContent } from './getFolderRowContent.mjs';
+import { LOCATION_DETAIL_VIEW_HEADERS } from './constants.mjs';
+
+const getLocationDetailViewTableData = ({ areAllFilesSelected, location, fileDataItems, hasFiles, pageItems, selectFileLabel, selectAllFilesLabel, getDateDisplayValue, onDownload, onNavigate, onSelect, onSelectAll, }) => {
+    const headerCheckbox = {
+        key: 'checkbox',
+        type: 'checkbox',
+        content: {
+            checked: areAllFilesSelected,
+            label: selectAllFilesLabel,
+            onSelect: onSelectAll,
+            id: 'header-checkbox',
+        },
+    };
+    const headers = hasFiles
+        ? [headerCheckbox, ...LOCATION_DETAIL_VIEW_HEADERS.slice(1)]
+        : LOCATION_DETAIL_VIEW_HEADERS;
+    const rows = pageItems.map((locationItem) => {
+        const { id, key, type } = locationItem;
+        switch (type) {
+            case 'FILE': {
+                const { lastModified, size } = locationItem;
+                const { current, path } = location;
+                const isSelected = fileDataItems?.some((item) => item.id === id) ?? false;
+                const onFileDownload = () => {
+                    onDownload(createFileDataItem(locationItem));
+                };
+                const onFileSelect = () => {
+                    onSelect(isSelected, locationItem);
+                };
+                return {
+                    key: id,
+                    content: getFileRowContent({
+                        permissions: current?.permissions ?? [],
+                        isSelected,
+                        itemLocationKey: `${current?.prefix ?? ''}${path}`,
+                        lastModified,
+                        getDateDisplayValue,
+                        rowId: id,
+                        rowKey: key,
+                        selectFileLabel,
+                        size,
+                        onDownload: onFileDownload,
+                        onSelect: onFileSelect,
+                    }),
+                };
+            }
+            case 'FOLDER': {
+                const { current, path } = location;
+                const itemSubPath = key.slice(`${current?.prefix ?? ''}${path}`.length);
+                const itemLocationPath = key.slice(current?.prefix.length);
+                const onFolderNavigate = () => {
+                    if (!current) {
+                        return;
+                    }
+                    onNavigate({ ...current, id }, itemLocationPath);
+                };
+                return {
+                    key: id,
+                    content: getFolderRowContent({
+                        itemSubPath,
+                        rowId: id,
+                        onNavigate: onFolderNavigate,
+                    }),
+                };
+            }
+        }
+    });
+    return { headers, rows };
+};
+
+export { getLocationDetailViewTableData };