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

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

@@ -10,8 +10,11 @@ var uiReact = require('@aws-amplify/ui-react');
 var elements = require('@aws-amplify/ui-react-core/elements');
 var internal = require('@aws-amplify/ui-react/internal');
 var uiReactCore = require('@aws-amplify/ui-react-core');
+var JSZip = require('jszip');
 var storage = require('aws-amplify/storage');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
 function _interopNamespace(e) {
     if (e && e.__esModule) return e;
     var n = Object.create(null);
@@ -31,8 +34,185 @@ function _interopNamespace(e) {
 }
 
 var React__namespace = /*#__PURE__*/_interopNamespace(React);
+var JSZip__default = /*#__PURE__*/_interopDefault(JSZip);
+
+const VERSION = '3.15.0';
+
+const DEFAULT_CHECKSUM_ALGORITHM = 'crc-32';
+// 5MiB for multipart upload
+// https://github.com/aws-amplify/amplify-js/blob/1a5366d113c9af4ce994168653df3aadb142c581/packages/storage/src/providers/s3/utils/constants.ts#L16
+const MULTIPART_UPLOAD_THRESHOLD_BYTES = 5 * 1024 * 1024;
 
-const VERSION = '3.14.0';
+const getBucketRegion = (bucketName, fallbackRegion) => {
+    try {
+        const config = awsAmplify.Amplify.getConfig()?.Storage?.S3;
+        if (!config?.buckets || typeof config.buckets !== 'object') {
+            return fallbackRegion;
+        }
+        for (const bucketConfig of Object.values(config.buckets)) {
+            if (bucketConfig.bucketName === bucketName && bucketConfig.region) {
+                return bucketConfig.region;
+            }
+        }
+        return fallbackRegion;
+    }
+    catch (error) {
+        return fallbackRegion;
+    }
+};
+const constructBucket$1 = ({ bucket: bucketName, region: globalRegion, }) => {
+    const bucketRegion = getBucketRegion(bucketName, globalRegion);
+    return { bucketName, region: bucketRegion };
+};
+const parseAccessGrantLocation = (location) => {
+    const { permission, scope, type } = location;
+    if (!scope.startsWith('s3://')) {
+        throw new Error(`Invalid scope: ${scope}`);
+    }
+    const id = crypto.randomUUID();
+    // remove default path
+    const slicedScope = scope.slice(5);
+    let bucket, prefix;
+    switch (type) {
+        case 'BUCKET': {
+            // { scope: 's3://bucket/*', type: 'BUCKET', },
+            bucket = slicedScope.slice(0, -2);
+            prefix = '';
+            break;
+        }
+        case 'PREFIX': {
+            // { scope: 's3://bucket/path/*', type: 'PREFIX', },
+            bucket = slicedScope.slice(0, slicedScope.indexOf('/'));
+            prefix = `${slicedScope.slice(bucket.length + 1, -1)}`;
+            break;
+        }
+        case 'OBJECT': {
+            // { scope: 's3://bucket/path/to/object', type: 'OBJECT', },
+            bucket = slicedScope.slice(0, slicedScope.indexOf('/'));
+            prefix = slicedScope.slice(bucket.length + 1);
+            break;
+        }
+        default: {
+            throw new Error(`Invalid location type: ${type}`);
+        }
+    }
+    let permissions;
+    switch (permission) {
+        case 'READ':
+            permissions = ['get', 'list'];
+            break;
+        case 'READWRITE':
+            permissions = ['delete', 'get', 'list', 'write'];
+            break;
+        case 'WRITE':
+            permissions = ['delete', 'write'];
+            break;
+        default:
+            throw new Error(`Invalid location permission: ${permission}`);
+    }
+    return { bucket, id, permissions: permissions, prefix, type };
+};
+const isSamePermissions = (permissionsToExclude, locationPermissions) => {
+    if (permissionsToExclude.length !== locationPermissions.length) {
+        return false;
+    }
+    const sortedLocationPermissions = locationPermissions.sort();
+    return permissionsToExclude
+        .sort()
+        .every((permission, index) => permission === sortedLocationPermissions[index]);
+};
+const isSameType = (typeToExclude, locationType) => typeof typeToExclude === 'string'
+    ? typeToExclude === locationType
+    : typeToExclude.includes(locationType);
+const shouldExcludeLocation = ({ permissions, type }, exclude) => {
+    const excludedByPermssions = !!(exclude?.exactPermissions &&
+        isSamePermissions(exclude.exactPermissions, permissions));
+    const excludedByType = !!(exclude?.type && isSameType(exclude.type, type));
+    return excludedByPermssions || excludedByType;
+};
+/**
+ * Determines if permissions1 is a strict superset (broader) of permissions2.
+ * Returns true only if permissions1 contains all permissions from permissions2
+ * AND has more permissions.
+ */
+const hasBroaderPermissions = (permissions1, permissions2) => {
+    // permissions1 must have more permissions (strict superset, not equal)
+    if (permissions1.length <= permissions2.length) {
+        return false;
+    }
+    // permissions1 must contain all permissions from permissions2
+    return permissions2.every((perm) => permissions1.includes(perm));
+};
+/**
+ * Deduplicates locations with the same bucket and prefix.
+ * Only deduplicates when one location's permissions are a superset of another's.
+ * This prevents deduplication of incompatible grants like READ + WRITE.
+ *
+ * Examples:
+ * - READ + READWRITE → Keep READWRITE (superset)
+ * - READ + READ → Keep first (identical)
+ * - READ + WRITE → Keep both (not superset, need separate locations)
+ */
+const deduplicateLocations = (locations) => {
+    // Group locations by bucket:prefix
+    const locationGroups = new Map();
+    for (const location of locations) {
+        const key = `${location.bucket}:${location.prefix}`;
+        const group = locationGroups.get(key) ?? [];
+        group.push(location);
+        locationGroups.set(key, group);
+    }
+    // For each group, keep only non-redundant locations
+    const result = [];
+    for (const group of locationGroups.values()) {
+        if (group.length === 1) {
+            result.push(group[0]);
+            continue;
+        }
+        // Find locations that are not subsets of any other location in the group
+        const nonRedundant = [];
+        for (const location of group) {
+            // Check if this location is a subset of any other location
+            const isSubsetOfAnother = group.some((other) => {
+                if (other === location)
+                    return false;
+                return hasBroaderPermissions(other.permissions, location.permissions);
+            });
+            if (!isSubsetOfAnother) {
+                // Check if we already have an identical permission set
+                const isDuplicate = nonRedundant.some((existing) => {
+                    const sortedNew = [...location.permissions].sort().join(',');
+                    const sortedExisting = [...existing.permissions].sort().join(',');
+                    return sortedNew === sortedExisting;
+                });
+                if (!isDuplicate) {
+                    nonRedundant.push(location);
+                }
+            }
+        }
+        result.push(...nonRedundant);
+    }
+    return result;
+};
+const getFilteredLocations = (locations, exclude) => locations.reduce((filteredLocations, location) => {
+    const parsedLocation = parseAccessGrantLocation(location);
+    const isNonFolderLikePrefix = !parsedLocation.prefix.endsWith('/') &&
+        parsedLocation.type === 'PREFIX';
+    if (isNonFolderLikePrefix) {
+        return filteredLocations;
+    }
+    if (!shouldExcludeLocation(parsedLocation, exclude)) {
+        filteredLocations.push(parsedLocation);
+    }
+    return filteredLocations;
+}, []);
+const getFileKey = (key) => key.slice(key.lastIndexOf('/') + 1, key.length);
+const createFileDataItem = (data) => ({
+    ...data,
+    fileKey: getFileKey(data.key),
+});
+const getProgress = ({ totalBytes, transferredBytes, }) => totalBytes ? transferredBytes / totalBytes : undefined;
+const isMultipartUpload = (file) => file.size > MULTIPART_UPLOAD_THRESHOLD_BYTES;
 
 const toAccessGrantPermission = (permission) => {
     let result = '';
@@ -118,7 +298,8 @@ const createAmplifyListLocationsHandler = () => {
                 id: crypto.randomUUID(),
             };
         });
-        cachedItems = sanitizedItems;
+        // Deduplicate locations with the same bucket and prefix, keeping broader permissions
+        cachedItems = deduplicateLocations(sanitizedItems);
         return getPaginatedLocations({
             items: cachedItems,
             pageSize,
@@ -163,123 +344,11 @@ const createAmplifyAuthAdapter = () => {
     };
 };
 
-const DEFAULT_CHECKSUM_ALGORITHM = 'crc-32';
-// 5MiB for multipart upload
-// https://github.com/aws-amplify/amplify-js/blob/1a5366d113c9af4ce994168653df3aadb142c581/packages/storage/src/providers/s3/utils/constants.ts#L16
-const MULTIPART_UPLOAD_THRESHOLD_BYTES = 5 * 1024 * 1024;
-
-const getBucketRegion = (bucketName, fallbackRegion) => {
-    try {
-        const config = awsAmplify.Amplify.getConfig()?.Storage?.S3;
-        if (!config?.buckets || typeof config.buckets !== 'object') {
-            return fallbackRegion;
-        }
-        for (const bucketConfig of Object.values(config.buckets)) {
-            if (bucketConfig.bucketName === bucketName && bucketConfig.region) {
-                return bucketConfig.region;
-            }
-        }
-        return fallbackRegion;
-    }
-    catch (error) {
-        return fallbackRegion;
-    }
-};
-const constructBucket = ({ bucket: bucketName, region: globalRegion, }) => {
-    const bucketRegion = getBucketRegion(bucketName, globalRegion);
-    return { bucketName, region: bucketRegion };
-};
-const parseAccessGrantLocation = (location) => {
-    const { permission, scope, type } = location;
-    if (!scope.startsWith('s3://')) {
-        throw new Error(`Invalid scope: ${scope}`);
-    }
-    const id = crypto.randomUUID();
-    // remove default path
-    const slicedScope = scope.slice(5);
-    let bucket, prefix;
-    switch (type) {
-        case 'BUCKET': {
-            // { scope: 's3://bucket/*', type: 'BUCKET', },
-            bucket = slicedScope.slice(0, -2);
-            prefix = '';
-            break;
-        }
-        case 'PREFIX': {
-            // { scope: 's3://bucket/path/*', type: 'PREFIX', },
-            bucket = slicedScope.slice(0, slicedScope.indexOf('/'));
-            prefix = `${slicedScope.slice(bucket.length + 1, -1)}`;
-            break;
-        }
-        case 'OBJECT': {
-            // { scope: 's3://bucket/path/to/object', type: 'OBJECT', },
-            bucket = slicedScope.slice(0, slicedScope.indexOf('/'));
-            prefix = slicedScope.slice(bucket.length + 1);
-            break;
-        }
-        default: {
-            throw new Error(`Invalid location type: ${type}`);
-        }
-    }
-    let permissions;
-    switch (permission) {
-        case 'READ':
-            permissions = ['get', 'list'];
-            break;
-        case 'READWRITE':
-            permissions = ['delete', 'get', 'list', 'write'];
-            break;
-        case 'WRITE':
-            permissions = ['delete', 'write'];
-            break;
-        default:
-            throw new Error(`Invalid location permission: ${permission}`);
-    }
-    return { bucket, id, permissions: permissions, prefix, type };
-};
-const isSamePermissions = (permissionsToExclude, locationPermissions) => {
-    if (permissionsToExclude.length !== locationPermissions.length) {
-        return false;
-    }
-    const sortedLocationPermissions = locationPermissions.sort();
-    return permissionsToExclude
-        .sort()
-        .every((permission, index) => permission === sortedLocationPermissions[index]);
-};
-const isSameType = (typeToExclude, locationType) => typeof typeToExclude === 'string'
-    ? typeToExclude === locationType
-    : typeToExclude.includes(locationType);
-const shouldExcludeLocation = ({ permissions, type }, exclude) => {
-    const excludedByPermssions = !!(exclude?.exactPermissions &&
-        isSamePermissions(exclude.exactPermissions, permissions));
-    const excludedByType = !!(exclude?.type && isSameType(exclude.type, type));
-    return excludedByPermssions || excludedByType;
-};
-const getFilteredLocations = (locations, exclude) => locations.reduce((filteredLocations, location) => {
-    const parsedLocation = parseAccessGrantLocation(location);
-    const isNonFolderLikePrefix = !parsedLocation.prefix.endsWith('/') &&
-        parsedLocation.type === 'PREFIX';
-    if (isNonFolderLikePrefix) {
-        return filteredLocations;
-    }
-    if (!shouldExcludeLocation(parsedLocation, exclude)) {
-        filteredLocations.push(parsedLocation);
-    }
-    return filteredLocations;
-}, []);
-const getFileKey = (key) => key.slice(key.lastIndexOf('/') + 1, key.length);
-const createFileDataItem = (data) => ({
-    ...data,
-    fileKey: getFileKey(data.key),
-});
-const getProgress = ({ totalBytes, transferredBytes, }) => totalBytes ? transferredBytes / totalBytes : undefined;
-const isMultipartUpload = (file) => file.size > MULTIPART_UPLOAD_THRESHOLD_BYTES;
-
 const copyHandler = (input) => {
     const { config, data } = input;
     const { accountId: expectedBucketOwner, credentials, customEndpoint, } = config;
     const { key, sourceKey, lastModified, eTag } = data;
-    const bucket = constructBucket(config);
+    const bucket = constructBucket$1(config);
     const source = {
         bucket,
         expectedBucketOwner,
@@ -320,7 +389,7 @@ const createFolderHandler = (input) => {
     const { accountId, credentials, customEndpoint } = config;
     const { onProgress } = options ?? {};
     const { key, preventOverwrite } = data;
-    const bucket = constructBucket(config);
+    const bucket = constructBucket$1(config);
     const { result } = internals.uploadData({
         path: key,
         data: '',
@@ -359,7 +428,7 @@ const deleteHandler = ({ config, data, }) => {
     const result = internals.remove({
         path: key,
         options: {
-            bucket: constructBucket(config),
+            bucket: constructBucket$1(config),
             locationCredentialsProvider: credentials,
             expectedBucketOwner: accountId,
             customEndpoint,
@@ -376,19 +445,115 @@ const deleteHandler = ({ config, data, }) => {
     return { result };
 };
 
-function downloadFromUrl(fileName, url) {
-    const a = document.createElement('a');
-    a.href = url;
-    a.download = fileName;
-    a.target = '_blank';
-    document.body.appendChild(a);
-    a.click();
-    document.body.removeChild(a);
-}
-const downloadHandler = ({ config, data }) => {
-    const { accountId, credentials, customEndpoint } = config;
+const zipProgressManager = ({ dataMap, onZipProgress, }) => {
+    const iter = (() => {
+        let f;
+        let i = 0;
+        return (str) => {
+            if (!f) {
+                f = str;
+            }
+            else if (str !== f) {
+                ++i;
+                f = str;
+            }
+            return i;
+        };
+    })();
+    const progressMap = new Map(Array.from(dataMap.keys()).map((k) => [k, 0]));
+    const total = dataMap.size;
+    dataMap.forEach((data, key) => {
+        onZipProgress(key, 0, data);
+    });
+    return ({ percent, currentFile, }) => {
+        if (currentFile) {
+            const item = iter(currentFile);
+            const sliceSize = 100 / total; // when 3 this is 33.3%
+            const start = sliceSize * item; // this is 66.6% for last item of 3;
+            // take percent and calculate the percent of the slice
+            const progress = percent - start;
+            const actualPercent = (progress / sliceSize) * 100;
+            progressMap.set(currentFile, Math.max(actualPercent, progressMap.get(currentFile) ?? 0));
+            onZipProgress(currentFile, progressMap.get(currentFile), dataMap.get(currentFile));
+        }
+    };
+};
+const zipper = (() => {
+    let zip = null;
+    const dataMap = new Map();
+    return {
+        addFile: (file, name, data) => {
+            if (!zip) {
+                zip = new JSZip__default["default"]();
+            }
+            dataMap.set(name, data);
+            return new Promise((ok, no) => {
+                try {
+                    zip?.file(name, file);
+                    ok();
+                }
+                catch (e) {
+                    no();
+                }
+            });
+        },
+        getBlobUrl: async (onProgress) => {
+            if (!zip) {
+                throw new Error('no zip');
+            }
+            const blob = await zip.generateAsync({
+                type: 'blob',
+                streamFiles: true,
+                compression: 'DEFLATE',
+                compressionOptions: {
+                    level: 5,
+                },
+            }, zipProgressManager({
+                dataMap,
+                onZipProgress: (file, progress, data) => {
+                    if (ui.isFunction(onProgress)) {
+                        onProgress(progress, file, data);
+                    }
+                },
+            }));
+            zip = null;
+            return URL.createObjectURL(blob);
+        },
+        destroy: () => {
+            dataMap.clear();
+            zip = null;
+        },
+    };
+})();
+const constructBucket = ({ bucket: bucketName, region, }) => ({ bucketName, region });
+const readBody = async (response, { data, options }) => {
+    let loading = true;
+    const chunks = [];
+    const reader = response.body.getReader();
+    const size = +(response.headers.get('content-length') ?? 0);
+    let received = 0;
+    while (loading) {
+        const { value, done } = await reader.read();
+        if (done) {
+            loading = false;
+        }
+        else {
+            chunks.push(value);
+            received += value.length;
+            if (ui.isFunction(options?.onProgress)) {
+                options?.onProgress(data, getProgress({
+                    totalBytes: size,
+                    transferredBytes: received,
+                }), 'PENDING');
+            }
+        }
+    }
+    return new Blob(chunks);
+};
+const download = async ({ config, data, all, options }, abortController) => {
+    const { customEndpoint, credentials, accountId } = config;
     const { key } = data;
-    const result = internals.getUrl({
+    const { url } = await internals.getUrl({
         path: key,
         options: {
             bucket: constructBucket(config),
@@ -398,17 +563,76 @@ const downloadHandler = ({ config, data }) => {
             contentDisposition: 'attachment',
             expectedBucketOwner: accountId,
         },
-    })
-        .then(({ url }) => {
-        downloadFromUrl(key, url.toString());
-        return { status: 'COMPLETE', value: { url } };
-    })
-        .catch((error) => {
-        const { message } = error;
-        return { error, message, status: 'FAILED' };
     });
-    return { result };
-};
+    const response = await fetch(url, {
+        mode: 'cors',
+        signal: abortController.signal,
+    });
+    const blob = await readBody(response, { data, options });
+    const [filename] = key.split('/').reverse();
+    await zipper.addFile(blob, filename, data);
+    return filename;
+};
+const downloadHandler = (() => {
+    const fileDownloadQueue = new Map();
+    const handler = ({ config, data, all, options }) => {
+        const { key } = data;
+        const [, folder] = key.split('/').reverse();
+        fileDownloadQueue.set(key, false);
+        const abortController = new AbortController();
+        return {
+            cancel: () => {
+                abortController.abort();
+                fileDownloadQueue.set(key, true);
+            },
+            result: download({ config, data, all, options }, abortController)
+                .then(() => {
+                fileDownloadQueue.set(key, true);
+                return {
+                    status: 'LOADED',
+                };
+            })
+                .catch((e) => {
+                const error = e;
+                fileDownloadQueue.set(key, true);
+                return {
+                    status: 'FAILED',
+                    message: error.message,
+                    error,
+                };
+            })
+                .finally(() => {
+                const done = all.every(({ key }) => {
+                    return fileDownloadQueue.get(key);
+                });
+                if (done) {
+                    zipper
+                        .getBlobUrl((percent, name, _data) => {
+                        if (ui.isFunction(options?.onProgress)) {
+                            const progress = percent / 100;
+                            options?.onProgress(_data, progress, progress === 1 ? 'COMPLETE' : 'FINISHING');
+                        }
+                    })
+                        .then((blobURL) => {
+                        if (blobURL) {
+                            zipper.destroy();
+                            const anchor = document.createElement('a');
+                            const clickEvent = new MouseEvent('click');
+                            anchor.href = blobURL;
+                            anchor.download = `${folder || 'archive'}.zip`;
+                            anchor.dispatchEvent(clickEvent);
+                        }
+                    })
+                        .catch(() => {
+                        // this catch happens, when no zip was created.
+                        // it is handled by the UI showing "FAILED" for all files
+                    });
+                }
+            }),
+        };
+    };
+    return handler;
+})();
 
 const DEFAULT_PAGE_SIZE$5 = 1000;
 const parseItems = (items, excludedPath) => items
@@ -494,7 +718,7 @@ const uploadHandler = ({ config, data, options }) => {
         path: key,
         data: file,
         options: {
-            bucket: constructBucket(config),
+            bucket: constructBucket$1(config),
             expectedBucketOwner: accountId,
             locationCredentialsProvider: credentials,
             onProgress: (event) => {
@@ -1719,8 +1943,10 @@ const USE_LIST_ERROR_MESSAGE = '`useList` must be called from within `StorageBro
 const INITIAL_STATUS_COUNTS = {
     CANCELED: 0,
     COMPLETE: 0,
+    LOADED: 0,
     FAILED: 0,
     PENDING: 0,
+    FINISHING: 0,
     OVERWRITE_PREVENTED: 0,
     QUEUED: 0,
     TOTAL: 0,
@@ -1731,7 +1957,10 @@ const isProcessingTasks = (statusCounts) => {
     if (statusCounts.TOTAL === 0 || statusCounts.TOTAL === statusCounts.QUEUED) {
         return false;
     }
-    return !(statusCounts.QUEUED === 0 && statusCounts.PENDING === 0);
+    return !(statusCounts.QUEUED === 0 &&
+        statusCounts.PENDING === 0 &&
+        statusCounts.LOADED === 0 &&
+        statusCounts.FINISHING === 0);
 };
 const hasCompletedProcessingTasks = (statusCounts) => {
     if (statusCounts.TOTAL === 0 || isProcessingTasks(statusCounts))
@@ -1829,20 +2058,26 @@ function useProcessTasks(handler, options) {
             : [...tasksRef.current.values()].find(({ status }) => status === 'QUEUED') ?? {};
         if (!data)
             return;
+        const all = isSingleTask
+            ? [_input.data]
+            : [...tasksRef.current.values()].map(({ data }) => data);
         const { onTaskCancel, onTaskComplete, onTaskError, onTaskProgress, onTaskSuccess, } = callbacksRef.current;
         const getTask = () => tasksRef.current.get(data.id);
         const { options } = _input;
         const { onProgress: _onProgress } = options ?? {};
-        const onProgress = ({ id }, progress) => {
-            const task = updateTask(id, { progress });
+        const onProgress = ({ id }, progress, status = 'PENDING') => {
+            const task = updateTask(id, {
+                progress,
+                status,
+            });
             if (task && ui.isFunction(onTaskProgress)) {
                 onTaskProgress(task, progress);
             }
             if (task && ui.isFunction(_onProgress)) {
-                _onProgress(data, progress);
+                _onProgress(data, progress, status);
             }
         };
-        const input = { ..._input, data, options: { ...options, onProgress } };
+        const input = { ..._input, data, all, options: { ...options, onProgress } };
         const { cancel: _cancel, result } = handler(input);
         const cancel = !_cancel
             ? undefined
@@ -1927,7 +2162,7 @@ function useHandler(handler, options) {
         handleProcessing({
             config,
             ...(hasData
-                ? { data: input.data }
+                ? { data: input.data, all: [input.data] }
                 : // if no `data` provided, provide `concurrency` to `options`
                     { options: { concurrency: DEFAULT_ACTION_CONCURRENCY } }),
         });
@@ -2036,8 +2271,10 @@ const DEFAULT_ACTION_VIEW_DISPLAY_TEXT = {
     actionDestinationLabel: 'Destination',
     statusDisplayCanceledLabel: 'Canceled',
     statusDisplayCompletedLabel: 'Completed',
+    statusDisplayLoadedLabel: 'Completed',
     statusDisplayFailedLabel: 'Failed',
     statusDisplayInProgressLabel: 'In progress',
+    statusDisplayFinishingLabel: 'In progress',
     statusDisplayTotalLabel: 'Total',
     statusDisplayQueuedLabel: 'Not started',
     // empty by default
@@ -2390,6 +2627,8 @@ const DEFAULT_DOWNLOAD_VIEW_DISPLAY_TEXT = {
     ...DEFAULT_ACTION_VIEW_DISPLAY_TEXT,
     title: 'Download',
     actionStartLabel: 'Download',
+    statusDisplayFinishingLabel: 'Zipping',
+    statusDisplayLoadedLabel: 'Loaded',
     getActionCompleteMessage: (data) => {
         const { counts } = data ?? {};
         const { COMPLETE, FAILED, TOTAL } = counts ?? {};
@@ -3746,15 +3985,19 @@ function useResolveTableData(keys, { getCell, getHeader, getRowKey }, { items, p
 
 const STATUS_LABELS = {
     PENDING: 'statusDisplayInProgressLabel',
+    FINISHING: 'statusDisplayFinishingLabel',
     CANCELED: 'statusDisplayCanceledLabel',
     COMPLETE: 'statusDisplayCompletedLabel',
+    LOADED: 'statusDisplayLoadedLabel',
     FAILED: 'statusDisplayFailedLabel',
     QUEUED: 'statusDisplayQueuedLabel',
     OVERWRITE_PREVENTED: 'statusDisplayOverwritePreventedLabel',
 };
 const STATUS_ICONS = {
     PENDING: 'action-progress',
+    FINISHING: 'action-progress',
     COMPLETE: 'action-success',
+    LOADED: 'action-success',
     FAILED: 'action-error',
     OVERWRITE_PREVENTED: 'action-info',
     CANCELED: 'action-canceled',
@@ -3795,7 +4038,7 @@ const getUploadCellProgress = ({ progress, status, }) => {
 };
 const getDownloadCellProgress = ({ progress, status, }) => {
     // prefer `progress` if available, 1 if status is complete, default 0
-    const value = progress ?? (status === 'COMPLETE' ? 1 : 0);
+    const value = progress ?? (status === 'LOADED' || status === 'COMPLETE' ? 1 : 0);
     const displayValue = `${Math.round(value * 100)}%`;
     return { displayValue, value };
 };
@@ -5536,7 +5779,7 @@ function useFilePreview({ activeFile, }) {
         const config = getConfig(location.current);
         const { accountId, customEndpoint, credentials } = config;
         const sharedOptions = {
-            bucket: constructBucket(config),
+            bucket: constructBucket$1(config),
             expectedBucketOwner: accountId,
         };
         try {
@@ -6368,6 +6611,7 @@ exports.VERSION = VERSION;
 exports.componentsDefault = componentsDefault;
 exports.createAmplifyAuthAdapter = createAmplifyAuthAdapter;
 exports.createStorageBrowser = createStorageBrowser;
+exports.deduplicateLocations = deduplicateLocations;
 exports.defaultActionConfigs = defaultActionConfigs;
 exports.defaultHandlers = defaultHandlers;
 exports.getFilteredLocations = getFilteredLocations;