@aws-amplify/ui-react-storage 3.3.10 → 3.4.1

package/dist/esm/browser.mjs

@@ -0,0 +1,4 @@
+export { componentsDefault } from './components/StorageBrowser/componentsDefault.mjs';
+export { createStorageBrowser } from './components/StorageBrowser/createStorageBrowser.mjs';
+export { createAmplifyAuthAdapter } from './components/StorageBrowser/adapters/createAmplifyAuthAdapter/createAmplifyAuthAdapter.mjs';
+export { createManagedAuthAdapter } from './components/StorageBrowser/adapters/createManagedAuthAdapter/createManagedAuthAdapter.mjs';

package/dist/esm/components/FileUploader/utils/getInput.mjs

@@ -26,7 +26,7 @@ const getInput = ({ accessLevel, file, key, onProgress, path, processFile, useAc
         else {
             const { identityId } = await fetchAuthSession();
             const resolvedPath = `${hasCallbackPath ? path({ identityId }) : path}${processedKey}`;
-            inputResult = { data: file, path: resolvedPath, options };
+            inputResult = { data, path: resolvedPath, options };
         }
         return inputResult;
     };

package/dist/esm/components/StorageBrowser/ComponentsProvider.mjs

@@ -0,0 +1,16 @@
+import React__default from 'react';
+import { ElementsProvider } from '@aws-amplify/ui-react-core/elements';
+import { ComposablesProvider } from './composables/context.mjs';
+import '@aws-amplify/ui-react';
+import './context/elements/definitions.mjs';
+import './context/elements/IconElement.mjs';
+import '@aws-amplify/ui';
+import '@aws-amplify/ui-react-core';
+
+function ComponentsProvider(props) {
+    const { children, composables, elements } = props;
+    return (React__default.createElement(ElementsProvider, { elements: elements },
+        React__default.createElement(ComposablesProvider, { composables: composables }, children)));
+}
+
+export { ComponentsProvider };

package/dist/esm/components/StorageBrowser/ErrorBoundary/ErrorBoundary.mjs

@@ -0,0 +1,25 @@
+import React__default from 'react';
+import { STORAGE_BROWSER_BLOCK_TO_BE_UPDATED } from '../constants.mjs';
+
+const Fallback = () => (React__default.createElement("div", { className: STORAGE_BROWSER_BLOCK_TO_BE_UPDATED },
+    React__default.createElement("div", { className: `${STORAGE_BROWSER_BLOCK_TO_BE_UPDATED}__error-boundary` }, "Something went wrong.")));
+class ErrorBoundary extends React__default.Component {
+    constructor(props) {
+        super(props);
+        this.state = { hasError: false };
+    }
+    static getDerivedStateFromError(_error) {
+        // Update state so the next render will show the fallback UI.
+        return { hasError: true };
+    }
+    render() {
+        const { hasError } = this.state;
+        const { children } = this.props;
+        if (hasError) {
+            return React__default.createElement(Fallback, null);
+        }
+        return children;
+    }
+}
+
+export { ErrorBoundary };

package/dist/esm/components/StorageBrowser/StorageBrowserAmplify.mjs

@@ -0,0 +1,19 @@
+import React__default from 'react';
+import { createStorageBrowser } from './createStorageBrowser.mjs';
+import { createAmplifyAuthAdapter } from './adapters/createAmplifyAuthAdapter/createAmplifyAuthAdapter.mjs';
+import '@aws-amplify/storage/internals';
+import './actions/configs/context.mjs';
+import '@aws-amplify/ui';
+import 'aws-amplify/storage';
+import '@aws-amplify/ui-react-core';
+import { componentsDefault } from './componentsDefault.mjs';
+
+const StorageBrowser = ({ views, displayText, }) => {
+    const { StorageBrowser } = React__default.useRef(createStorageBrowser({
+        components: componentsDefault,
+        config: createAmplifyAuthAdapter(),
+    })).current;
+    return React__default.createElement(StorageBrowser, { views: views, displayText: displayText });
+};
+
+export { StorageBrowser };

package/dist/esm/components/StorageBrowser/StorageBrowserDefault.mjs

@@ -0,0 +1,42 @@
+import React__default from 'react';
+import './views/LocationActionView/CopyView/CopyView.mjs';
+import '@aws-amplify/ui';
+import '@aws-amplify/storage/internals';
+import 'aws-amplify/storage';
+import './providers/configuration/context.mjs';
+import '@aws-amplify/ui-react-core/elements';
+import './actions/configs/context.mjs';
+import '@aws-amplify/ui-react-core';
+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 './views/LocationActionView/CreateFolderView/CreateFolderView.mjs';
+import './views/LocationActionView/DeleteView/DeleteView.mjs';
+import './views/LocationActionView/UploadView/UploadView.mjs';
+import './views/LocationDetailView/LocationDetailView.mjs';
+import './views/LocationsView/LocationsView.mjs';
+import { useViews } from './views/context.mjs';
+
+/**
+ * Handles default `StorageBrowser` behavior:
+ * - render `LocationsView` on init
+ * - render `LocationDetailView` on location selection
+ * - render `ActionView` on action selection
+ */
+function StorageBrowserDefault() {
+    const { LocationActionView, LocationDetailView, LocationsView } = useViews();
+    const [{ actionType, location }] = useStore();
+    const { current } = location;
+    if (actionType) {
+        return React__default.createElement(LocationActionView, null);
+    }
+    if (current) {
+        return React__default.createElement(LocationDetailView, null);
+    }
+    return React__default.createElement(LocationsView, null);
+}
+
+export { StorageBrowserDefault };

package/dist/esm/components/StorageBrowser/actions/configs/context.mjs

@@ -0,0 +1,13 @@
+import { createContextUtilities } from '@aws-amplify/ui-react-core';
+
+const defaultValue = { actions: undefined };
+const { useActionConfigs, ActionConfigsProvider } = createContextUtilities({ contextName: 'ActionConfigs', defaultValue });
+function useActionConfig(type) {
+    const { actions } = useActionConfigs();
+    const config = actions?.[type];
+    if (!config)
+        throw new Error('No action!');
+    return config;
+}
+
+export { ActionConfigsProvider, useActionConfig, useActionConfigs };

package/dist/esm/components/StorageBrowser/actions/configs/defaults.mjs

@@ -0,0 +1,87 @@
+import { copyHandler } from '../handlers/copy.mjs';
+import { createFolderHandler } from '../handlers/createFolder.mjs';
+import { deleteHandler } from '../handlers/delete.mjs';
+import '@aws-amplify/storage/internals';
+import { listLocationItemsHandler } from '../handlers/listLocationItems.mjs';
+import { listLocationsHandler } from '../handlers/listLocations.mjs';
+import { uploadHandler } from '../handlers/upload.mjs';
+
+const copyActionConfig = {
+    componentName: 'CopyView',
+    actionsListItemConfig: {
+        disable: (selected) => !selected || selected.length === 0,
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'copy-file',
+        label: 'Copy',
+    },
+    displayName: 'Copy',
+    handler: copyHandler,
+};
+const deleteActionConfig = {
+    componentName: 'DeleteView',
+    actionsListItemConfig: {
+        disable: (selected) => !selected || selected.length === 0,
+        hide: (permissions) => !permissions.includes('delete'),
+        icon: 'delete-file',
+        label: 'Delete',
+    },
+    displayName: 'Delete',
+    handler: deleteHandler,
+};
+const createFolderActionConfig = {
+    componentName: 'CreateFolderView',
+    actionsListItemConfig: {
+        disable: () => false,
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'create-folder',
+        label: 'Create folder',
+    },
+    handler: createFolderHandler,
+    isCancelable: false,
+    displayName: 'Create Folder',
+};
+const listLocationItemsActionConfig = {
+    componentName: 'LocationDetailView',
+    handler: listLocationItemsHandler,
+    displayName: (bucket, prefix) => {
+        if (bucket && prefix) {
+            const prefixes = prefix.split('/');
+            return `${bucket}: ${prefixes.length > 2 ? `../${prefixes[prefixes.length - 2]}/` : prefix}`;
+        }
+        return !bucket ? '-' : bucket;
+    },
+};
+const listLocationsActionConfig = {
+    componentName: 'LocationsView',
+    handler: listLocationsHandler,
+    displayName: 'Home',
+};
+const uploadActionConfig = {
+    componentName: 'UploadView',
+    actionsListItemConfig: {
+        disable: () => false,
+        fileSelection: 'FILE',
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'upload-file',
+        label: 'Upload',
+    },
+    isCancelable: true,
+    includeProgress: true,
+    handler: uploadHandler,
+    displayName: 'Upload',
+};
+const defaultActionViewConfigs = {
+    copy: copyActionConfig,
+    createFolder: createFolderActionConfig,
+    delete: deleteActionConfig,
+    upload: uploadActionConfig,
+};
+const DEFAULT_ACTION_VIEW_TYPES = Object.keys(defaultActionViewConfigs);
+const isDefaultActionViewType = (value) => DEFAULT_ACTION_VIEW_TYPES.some((type) => type === value);
+const defaultActionConfigs = {
+    ...defaultActionViewConfigs,
+    listLocationItems: listLocationItemsActionConfig,
+    listLocations: listLocationsActionConfig,
+};
+
+export { DEFAULT_ACTION_VIEW_TYPES, copyActionConfig, createFolderActionConfig, defaultActionConfigs, defaultActionViewConfigs, deleteActionConfig, isDefaultActionViewType, listLocationItemsActionConfig, listLocationsActionConfig, uploadActionConfig };

package/dist/esm/components/StorageBrowser/actions/handlers/copy.mjs

@@ -0,0 +1,41 @@
+import { copy } from '@aws-amplify/storage/internals';
+import { constructBucket } from './utils.mjs';
+
+const copyHandler = (input) => {
+    const { config, destinationPrefix: path, data } = input;
+    const { accountId: expectedBucketOwner, credentials, customEndpoint, } = config;
+    const { key: sourcePath, fileKey, lastModified, eTag } = data;
+    const bucket = constructBucket(config);
+    const destinationPath = `${path}${fileKey}`;
+    const source = {
+        bucket,
+        expectedBucketOwner,
+        /**
+         * Per S3 requirement, copy source must the URI encoded.
+         * This is NOT added to Amplify JS v6 because it will be a breaking
+         * change to suddenly introduce URI encode to copy API source.
+         *
+         * see: https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html#API_CopyObject_RequestSyntax
+         */
+        path: sourcePath.split('/').map(encodeURIComponent).join('/'),
+        notModifiedSince: lastModified,
+        eTag,
+    };
+    const destination = {
+        bucket,
+        expectedBucketOwner,
+        path: destinationPath,
+    };
+    const result = copy({
+        source,
+        destination,
+        options: { locationCredentialsProvider: credentials, customEndpoint },
+    });
+    return {
+        result: result
+            .then(() => ({ status: 'COMPLETE' }))
+            .catch(({ message }) => ({ message, status: 'FAILED' })),
+    };
+};
+
+export { copyHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/createFolder.mjs

@@ -0,0 +1,38 @@
+import { uploadData } from '@aws-amplify/storage/internals';
+import { isFunction } from '@aws-amplify/ui';
+import { getProgress, constructBucket } from './utils.mjs';
+
+const createFolderHandler = (input) => {
+    const { destinationPrefix, config, data, options } = input;
+    const { accountId, credentials, customEndpoint } = config;
+    const { onProgress, preventOverwrite } = options ?? {};
+    const { key } = data;
+    const bucket = constructBucket(config);
+    const { result } = uploadData({
+        path: `${destinationPrefix}${key}`,
+        data: '',
+        options: {
+            bucket,
+            expectedBucketOwner: accountId,
+            locationCredentialsProvider: credentials,
+            customEndpoint,
+            onProgress: (event) => {
+                if (isFunction(onProgress))
+                    onProgress(data, getProgress(event));
+            },
+            preventOverwrite,
+        },
+    });
+    return {
+        result: result
+            .then(() => ({ status: 'COMPLETE' }))
+            .catch(({ message, name }) => {
+            if (name === 'PreconditionFailed') {
+                return { message, status: 'OVERWRITE_PREVENTED' };
+            }
+            return { message, status: 'FAILED' };
+        }),
+    };
+};
+
+export { createFolderHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/delete.mjs

@@ -0,0 +1,22 @@
+import { remove } from '@aws-amplify/storage/internals';
+import { constructBucket } from './utils.mjs';
+
+const deleteHandler = ({ config, data: { key }, }) => {
+    const { accountId, credentials, customEndpoint } = config;
+    const result = remove({
+        path: key,
+        options: {
+            bucket: constructBucket(config),
+            locationCredentialsProvider: credentials,
+            expectedBucketOwner: accountId,
+            customEndpoint,
+        },
+    });
+    return {
+        result: result
+            .then(() => ({ status: 'COMPLETE' }))
+            .catch(({ message }) => ({ message, status: 'FAILED' })),
+    };
+};
+
+export { deleteHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/download.mjs

@@ -0,0 +1,38 @@
+import { getUrl } from '@aws-amplify/storage/internals';
+import { constructBucket } from './utils.mjs';
+
+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: { key }, }) => {
+    const { accountId, credentials, customEndpoint } = config;
+    const result = getUrl({
+        path: key,
+        options: {
+            bucket: constructBucket(config),
+            customEndpoint,
+            locationCredentialsProvider: credentials,
+            validateObjectExistence: true,
+            contentDisposition: 'attachment',
+            expectedBucketOwner: accountId,
+        },
+    }).then((result) => {
+        return result;
+    });
+    return {
+        result: result
+            .then(({ url }) => {
+            downloadFromUrl(key, url.toString());
+            return { status: 'COMPLETE' };
+        })
+            .catch(({ message }) => ({ message, status: 'FAILED' })),
+    };
+};
+
+export { downloadHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/listLocationItems.mjs

@@ -0,0 +1,73 @@
+import { list } from '@aws-amplify/storage/internals';
+
+const DEFAULT_PAGE_SIZE = 1000;
+const parseItems = (items, excludedPath) => items
+    // remove root `key` from results
+    .filter(({ path }) => path !== excludedPath)
+    .map(({ path: key, lastModified, size, eTag }) => {
+    const id = crypto.randomUUID();
+    // Mark zero byte files as Folders
+    if (size === 0 && key.endsWith('/')) {
+        return { key, id, type: 'FOLDER' };
+    }
+    return {
+        key,
+        id,
+        eTag,
+        lastModified: lastModified,
+        size: size,
+        type: 'FILE',
+    };
+});
+const parseExcludedPaths = (paths) => paths?.map((key) => ({ key, id: crypto.randomUUID(), type: 'FOLDER' })) ?? [];
+const filterDotItems = (items, prefix) => items.filter((item) => {
+    const key = (item.key.startsWith(prefix) ? item.key.substring(prefix.length) : item.key).trim();
+    // matches object keys that would cause problems either as folder names in navigation (`/`, `./`, `../`) or as objects (`.`, `..`)
+    return !(key === '/' ||
+        key === './' ||
+        key === '../' ||
+        key === '.' ||
+        key === '..');
+});
+const parseResult = ({ excludedSubpaths, items }, prefix) => filterDotItems([...parseExcludedPaths(excludedSubpaths), ...parseItems(items, prefix)], prefix);
+const listLocationItemsHandler = async (input) => {
+    const { config, prefix, options } = input;
+    const { bucket: _bucket, credentials, customEndpoint, region, accountId, } = config;
+    const { exclude, delimiter, nextToken, pageSize: _pageSize = DEFAULT_PAGE_SIZE, ..._options } = options ?? {};
+    const bucket = { bucketName: _bucket, region };
+    const subpathStrategy = {
+        delimiter,
+        strategy: delimiter ? 'exclude' : 'include',
+    };
+    // `ListObjectsV2` returns the root `key` on initial request, which is from
+    // filtered from `results` by `parseResult`, creatimg a scenario where the
+    // return count of `results` to be one item less than provided the `pageSize`.
+    // To mitigate, if a `pageSize` is provided and there are no previous `results`
+    // or `refresh` is `true` increment the provided `pageSize` by `1`
+    const hasOffset = !nextToken;
+    const pageSize = hasOffset ? _pageSize + 1 : _pageSize;
+    const result = [];
+    let nextNextToken = nextToken;
+    do {
+        const listInput = {
+            path: prefix,
+            options: {
+                nextToken: nextNextToken,
+                ..._options,
+                bucket,
+                customEndpoint,
+                expectedBucketOwner: accountId,
+                locationCredentialsProvider: credentials,
+                pageSize,
+                subpathStrategy,
+            },
+        };
+        const output = await list(listInput);
+        nextNextToken = output.nextToken;
+        const items = parseResult(output, prefix);
+        result.push(...(exclude ? items.filter((item) => item.type !== exclude) : items));
+    } while (nextNextToken && result.length < pageSize);
+    return { items: result, nextToken: nextNextToken };
+};
+
+export { filterDotItems, listLocationItemsHandler, parseResult };

package/dist/esm/components/StorageBrowser/actions/handlers/listLocations.mjs

@@ -0,0 +1,32 @@
+import { listCallerAccessGrants } from '@aws-amplify/storage/internals';
+import '@aws-amplify/ui';
+import { assertAccountId } from '../../validators/assertAccountId.mjs';
+import { getFilteredLocations } from './utils.mjs';
+
+const DEFAULT_PAGE_SIZE = 1000;
+const listLocationsHandler = async (input) => {
+    const { config, options } = input;
+    const { accountId, credentials, customEndpoint, region } = config;
+    const { exclude, nextToken, pageSize = DEFAULT_PAGE_SIZE } = options ?? {};
+    const fetchLocations = async (accumulatedItems, locationsNextToken) => {
+        const remainingPageSize = pageSize - accumulatedItems.length;
+        assertAccountId(accountId);
+        const output = await listCallerAccessGrants({
+            accountId,
+            credentialsProvider: credentials,
+            customEndpoint,
+            nextToken: locationsNextToken,
+            pageSize: remainingPageSize,
+            region,
+        });
+        const parsedOutput = getFilteredLocations(output.locations, exclude);
+        const items = [...accumulatedItems, ...parsedOutput];
+        if (output.nextToken && items.length < pageSize) {
+            return fetchLocations(items, output.nextToken);
+        }
+        return { items, nextToken: output.nextToken };
+    };
+    return fetchLocations([], nextToken);
+};
+
+export { listLocationsHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/upload.mjs

@@ -0,0 +1,54 @@
+import { isCancelError } from 'aws-amplify/storage';
+import { isFunction } from '@aws-amplify/ui';
+import { uploadData } from '@aws-amplify/storage/internals';
+import { constructBucket, getProgress } from './utils.mjs';
+
+// 5MB for multipart upload
+// https://github.com/aws-amplify/amplify-js/blob/1a5366d113c9af4ce994168653df3aadb142c581/packages/storage/src/providers/s3/utils/constants.ts#L16
+const MULTIPART_UPLOAD_THRESHOLD_BYTES = 5 * 1024 * 1024;
+const UNDEFINED_CALLBACKS = {
+    cancel: undefined,
+    pause: undefined,
+    resume: undefined,
+};
+const uploadHandler = ({ config, data, destinationPrefix, options, }) => {
+    const { accountId, credentials, customEndpoint } = config;
+    const { key, file } = data;
+    const { onProgress, preventOverwrite } = options ?? {};
+    const input = {
+        path: `${destinationPrefix}${key}`,
+        data: file,
+        options: {
+            bucket: constructBucket(config),
+            expectedBucketOwner: accountId,
+            locationCredentialsProvider: credentials,
+            onProgress: (event) => {
+                if (isFunction(onProgress))
+                    onProgress(data, getProgress(event));
+            },
+            preventOverwrite,
+            customEndpoint,
+            checksumAlgorithm: 'crc-32',
+        },
+    };
+    const { cancel, pause, resume, result } = uploadData(input);
+    return {
+        ...(file.size > MULTIPART_UPLOAD_THRESHOLD_BYTES
+            ? { cancel, pause, resume }
+            : UNDEFINED_CALLBACKS),
+        result: result
+            .then(() => ({ status: 'COMPLETE' }))
+            .catch((error) => {
+            const { message } = error;
+            if (error.name === 'PreconditionFailed') {
+                return { message, status: 'OVERWRITE_PREVENTED' };
+            }
+            return {
+                message,
+                status: isCancelError(error) ? 'CANCELED' : 'FAILED',
+            };
+        }),
+    };
+};
+
+export { MULTIPART_UPLOAD_THRESHOLD_BYTES, UNDEFINED_CALLBACKS, uploadHandler };

package/dist/esm/components/StorageBrowser/actions/handlers/utils.mjs

@@ -0,0 +1,99 @@
+const constructBucket = ({ bucket: bucketName, region, }) => ({ bucketName, region });
+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 createFileDataItemFromLocation = (data) => ({
+    id: data.id,
+    type: 'FILE',
+    key: data.prefix,
+    fileKey: getFileKey(data.prefix),
+    // `lastModified` and `size` included to satisfy
+    // expected shape of `FileDataItem`
+    lastModified: new Date(),
+    size: 0,
+});
+const isFileItem = (value) => !!value.file;
+const isFileDataItem = (item) => !!item.fileKey;
+const getProgress = ({ totalBytes, transferredBytes, }) => totalBytes ? transferredBytes / totalBytes : undefined;
+
+export { constructBucket, createFileDataItem, createFileDataItemFromLocation, getFileKey, getFilteredLocations, getProgress, isFileDataItem, isFileItem, parseAccessGrantLocation, shouldExcludeLocation };