@aws-amplify/ui-react-storage 0.0.0-studio-console-80bb2e2-20230921222703 → 0.0.0-testdelay-84839eb-20250107181059

package/dist/esm/components/FileUploader/ui/FileListHeader/FileListHeader.mjs

@@ -0,0 +1,14 @@
+import React__default from 'react';
+import { ComponentClassName } from '@aws-amplify/ui';
+import { Text } from '@aws-amplify/ui-react';
+
+function FileListHeader({ allUploadsSuccessful, displayText, fileCount, remainingFilesCount, selectedFilesCount = 0, }) {
+    const { getFilesUploadedText, getRemainingFilesText, getSelectedFilesText } = displayText;
+    return (React__default.createElement(Text, { className: ComponentClassName.FileUploaderPreviewerText }, selectedFilesCount
+        ? getSelectedFilesText(selectedFilesCount)
+        : allUploadsSuccessful
+            ? getFilesUploadedText(fileCount)
+            : getRemainingFilesText(remainingFilesCount)));
+}
+
+export { FileListHeader };

package/dist/esm/components/FileUploader/ui/FilePicker/FilePicker.mjs

@@ -0,0 +1,9 @@
+import React__default from 'react';
+import { ComponentClassName } from '@aws-amplify/ui';
+import { Button } from '@aws-amplify/ui-react';
+
+function FilePicker({ children, className = ComponentClassName.FileUploaderFilePicker, size = 'small', ...props }) {
+    return (React__default.createElement(Button, { ...props, className: className, size: size }, children));
+}
+
+export { FilePicker };

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

@@ -0,0 +1,12 @@
+import { humanFileSize } from '@aws-amplify/ui';
+
+const checkMaxFileSize = ({ file, getFileSizeErrorText, maxFileSize, }) => {
+    if (maxFileSize === undefined)
+        return '';
+    if (file.size > maxFileSize) {
+        return getFileSizeErrorText(humanFileSize(maxFileSize, true));
+    }
+    return '';
+};
+
+export { checkMaxFileSize };

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

@@ -0,0 +1,39 @@
+const defaultFileUploaderDisplayText = {
+    getFilesUploadedText(count) {
+        return `${count} ${count === 1 ? 'file uploaded' : 'files uploaded'}`;
+    },
+    getFileSizeErrorText(sizeText) {
+        return `File size must be below ${sizeText}`;
+    },
+    getRemainingFilesText(count) {
+        return `${count} ${count === 1 ? 'file' : 'files'} uploading`;
+    },
+    getSelectedFilesText(count) {
+        return `${count} ${count === 1 ? 'file' : 'files'} selected`;
+    },
+    getUploadingText(percentage) {
+        return `Uploading${percentage > 0 ? `: ${percentage}%` : ''}`;
+    },
+    getUploadButtonText(count) {
+        return `Upload ${count} ${count === 1 ? 'file' : 'files'}`;
+    },
+    getMaxFilesErrorText(count) {
+        return `Cannot choose more than ${count} ${count === 1 ? 'file' : 'files'}. Remove files before updating`;
+    },
+    getErrorText(message) {
+        return message;
+    },
+    doneButtonText: 'Done',
+    clearAllButtonText: 'Clear all',
+    extensionNotAllowedText: 'Extension not allowed',
+    browseFilesText: 'Browse files',
+    dropFilesText: 'Drop files here or',
+    pauseButtonText: 'Pause',
+    resumeButtonText: 'Resume',
+    uploadSuccessfulText: 'Uploaded',
+    getPausedText(percentage) {
+        return `Paused: ${percentage}%`;
+    },
+};
+
+export { defaultFileUploaderDisplayText };

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

@@ -0,0 +1,27 @@
+const filterAllowedFiles = (files, acceptedFileTypes) => {
+    // Allow any files if acceptedFileTypes is undefined, empty array, or contains '*'
+    if (!acceptedFileTypes ||
+        acceptedFileTypes.length === 0 ||
+        acceptedFileTypes.includes('*')) {
+        return files;
+    }
+    // Remove any files that are not in the accepted file list
+    return files.filter((file) => {
+        const fileName = file.name || '';
+        const mimeType = (file.type || '').toLowerCase();
+        const baseMimeType = mimeType.replace(/\/.*$/, '');
+        return acceptedFileTypes.some((type) => {
+            const validType = type.trim().toLowerCase();
+            if (validType.charAt(0) === '.') {
+                return fileName.toLowerCase().endsWith(validType);
+            }
+            else if (validType.endsWith('/*')) {
+                // This is something like a image/* mime type
+                return baseMimeType === validType.replace(/\/.*$/, '');
+            }
+            return mimeType === validType;
+        });
+    });
+};
+
+export { filterAllowedFiles };

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

@@ -0,0 +1,35 @@
+import { fetchAuthSession } from 'aws-amplify/auth';
+import { isFunction, isString } from '@aws-amplify/ui';
+import { resolveFile } from './resolveFile.mjs';
+
+const getInput = ({ accessLevel, file, key, onProgress, path, processFile, useAccelerateEndpoint, }) => {
+    return async () => {
+        const hasCallbackPath = isFunction(path);
+        const hasStringPath = isString(path);
+        const hasKeyInput = !!accessLevel && !hasCallbackPath;
+        const { file: data, key: processedKey, ...rest } = await resolveFile({ file, key, processFile });
+        const contentType = file.type || 'binary/octet-stream';
+        // IMPORTANT: always pass `...rest` here for backwards compatibility
+        const options = { contentType, onProgress, useAccelerateEndpoint, ...rest };
+        let inputResult;
+        if (hasKeyInput) {
+            // legacy handling of `path` is to prefix to `fileKey`
+            const resolvedKey = hasStringPath
+                ? `${path}${processedKey}`
+                : processedKey;
+            inputResult = {
+                data,
+                key: resolvedKey,
+                options: { ...options, accessLevel },
+            };
+        }
+        else {
+            const { identityId } = await fetchAuthSession();
+            const resolvedPath = `${hasCallbackPath ? path({ identityId }) : path}${processedKey}`;
+            inputResult = { data, path: resolvedPath, options };
+        }
+        return inputResult;
+    };
+};
+
+export { getInput };

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

@@ -0,0 +1,20 @@
+import { isFunction } from '@aws-amplify/ui';
+
+/**
+ * Utility function that takes the processFile prop, along with a file a key
+ * and returns a Promise that resolves to { file, key, ..rest }
+ * regardless if processFile is defined and if it is sync or async
+ */
+const resolveFile = ({ processFile, ...input }) => {
+    return new Promise((resolve, reject) => {
+        const result = isFunction(processFile) ? processFile(input) : input;
+        if (result instanceof Promise) {
+            result.then(resolve).catch(reject);
+        }
+        else {
+            resolve(result);
+        }
+    });
+};
+
+export { resolveFile };

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

@@ -0,0 +1,26 @@
+import { uploadData } from 'aws-amplify/storage';
+import { isFunction } from '@aws-amplify/ui';
+
+async function uploadFile({ input, onError, onStart, onComplete, }) {
+    const resolvedInput = await input();
+    const uploadTask = uploadData(resolvedInput);
+    const key = resolvedInput?.key ??
+        resolvedInput?.path;
+    if (isFunction(onStart)) {
+        onStart({ key, uploadTask });
+    }
+    uploadTask.result
+        .then((result) => {
+        if (isFunction(onComplete) && uploadTask.state === 'SUCCESS') {
+            onComplete(result);
+        }
+    })
+        .catch((error) => {
+        if (isFunction(onError)) {
+            onError({ key, error });
+        }
+    });
+    return uploadTask;
+}
+
+export { uploadFile };

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,14 @@
+import React__default from 'react';
+import { createStorageBrowser } from './createStorageBrowser.mjs';
+import { createAmplifyAuthAdapter } from './adapters/createAmplifyAuthAdapter/createAmplifyAuthAdapter.mjs';
+import '@aws-amplify/storage/internals';
+import '@aws-amplify/ui';
+import 'aws-amplify/storage';
+import './actions/configs/context.mjs';
+
+const StorageBrowser = ({ views, displayText, }) => {
+    const { StorageBrowser } = React__default.useRef(createStorageBrowser({ config: createAmplifyAuthAdapter() })).current;
+    return React__default.createElement(StorageBrowser, { views: views, displayText: displayText });
+};
+
+export { StorageBrowser };

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

@@ -0,0 +1,29 @@
+import React__default from 'react';
+import { useViews } from './views/context/views.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';
+
+/**
+ * Handles default `StorageBrowser` behavior:
+ * - render `LocationsView` on init
+ * - render `LocationDetailView` on location selection
+ * - render `ActionView` on action selection
+ */
+function StorageBrowserDefault() {
+    const { primary } = useViews();
+    const { LocationActionView, LocationDetailView, LocationsView } = primary;
+    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,8 @@
+import { createContextUtilities } from '@aws-amplify/ui-react-core';
+
+const defaultValue = {
+    actionConfigs: undefined,
+};
+const { useActionConfigs, ActionConfigsProvider } = createContextUtilities({ contextName: 'ActionConfigs', defaultValue });
+
+export { ActionConfigsProvider, useActionConfigs };

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

@@ -0,0 +1,62 @@
+import { copyHandler } from '../handlers/copy.mjs';
+import { createFolderHandler } from '../handlers/createFolder.mjs';
+import { deleteHandler } from '../handlers/delete.mjs';
+import { downloadHandler } from '../handlers/download.mjs';
+import { listLocationItemsHandler } from '../handlers/listLocationItems.mjs';
+import '@aws-amplify/storage/internals';
+import '@aws-amplify/ui';
+import { uploadHandler } from '../handlers/upload.mjs';
+
+const copyActionConfig = {
+    viewName: 'CopyView',
+    actionListItem: {
+        disable: (selected) => !selected || selected.length === 0,
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'copy-file',
+        label: 'Copy',
+    },
+    handler: copyHandler,
+};
+const deleteActionConfig = {
+    viewName: 'DeleteView',
+    actionListItem: {
+        disable: (selected) => !selected || selected.length === 0,
+        hide: (permissions) => !permissions.includes('delete'),
+        icon: 'delete-file',
+        label: 'Delete',
+    },
+    handler: deleteHandler,
+};
+const createFolderActionConfig = {
+    viewName: 'CreateFolderView',
+    actionListItem: {
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'create-folder',
+        label: 'Create folder',
+    },
+    handler: createFolderHandler,
+};
+const uploadActionConfig = {
+    viewName: 'UploadView',
+    actionListItem: {
+        hide: (permissions) => !permissions.includes('write'),
+        icon: 'upload-file',
+        label: 'Upload',
+    },
+    handler: uploadHandler,
+};
+const defaultActionViewConfigs = {
+    copy: copyActionConfig,
+    createFolder: createFolderActionConfig,
+    download: downloadHandler,
+    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: listLocationItemsHandler,
+};
+
+export { DEFAULT_ACTION_VIEW_TYPES, copyActionConfig, createFolderActionConfig, defaultActionConfigs, defaultActionViewConfigs, deleteActionConfig, isDefaultActionViewType, uploadActionConfig };

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

@@ -0,0 +1,8 @@
+import { isObject } from '@aws-amplify/ui';
+
+const isActionConfig = (value) => isObject(value);
+const getActionConfigs = (configs) => {
+    return Object.entries({ ...configs.default, ...configs.custom }).reduce((configs, [type, config]) => !isActionConfig(config) ? configs : { ...configs, [type]: config }, {});
+};
+
+export { getActionConfigs };

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, data } = input;
+    const { accountId: expectedBucketOwner, credentials, customEndpoint, } = config;
+    const { key, sourceKey, lastModified, eTag } = data;
+    const bucket = constructBucket(config);
+    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: sourceKey.split('/').map(encodeURIComponent).join('/'),
+        notModifiedSince: lastModified,
+        eTag,
+    };
+    const destination = {
+        bucket,
+        expectedBucketOwner,
+        path: key,
+    };
+    const result = copy({
+        source,
+        destination,
+        options: { locationCredentialsProvider: credentials, customEndpoint },
+    });
+    return {
+        result: result
+            .then(({ path }) => ({
+            status: 'COMPLETE',
+            value: { key: path },
+        }))
+            .catch(({ message }) => ({ message, status: 'FAILED' })),
+    };
+};
+
+export { copyHandler };

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

@@ -0,0 +1,41 @@
+import { isFunction } from '@aws-amplify/ui';
+import { uploadData } from '@aws-amplify/storage/internals';
+import { getProgress, constructBucket } from './utils.mjs';
+
+const createFolderHandler = (input) => {
+    const { config, data, options } = input;
+    const { accountId, credentials, customEndpoint } = config;
+    const { onProgress } = options ?? {};
+    const { key, preventOverwrite } = data;
+    const bucket = constructBucket(config);
+    const { result } = uploadData({
+        path: key,
+        data: '',
+        options: {
+            bucket,
+            expectedBucketOwner: accountId,
+            locationCredentialsProvider: credentials,
+            customEndpoint,
+            onProgress: (event) => {
+                if (isFunction(onProgress))
+                    onProgress(data, getProgress(event));
+            },
+            preventOverwrite,
+        },
+    });
+    return {
+        result: result
+            .then(({ path }) => ({
+            status: 'COMPLETE',
+            value: { key: path },
+        }))
+            .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,24 @@
+import { remove } from '@aws-amplify/storage/internals';
+import { constructBucket } from './utils.mjs';
+
+const deleteHandler = ({ config, data, }) => {
+    const { key } = data;
+    const { accountId, credentials, customEndpoint } = config;
+    const result = remove({
+        path: key,
+        options: {
+            bucket: constructBucket(config),
+            locationCredentialsProvider: credentials,
+            expectedBucketOwner: accountId,
+            customEndpoint,
+        },
+    })
+        .then(({ path }) => ({
+        status: 'COMPLETE',
+        value: { key: path },
+    }))
+        .catch(({ message }) => ({ message, status: 'FAILED' }));
+    return { result };
+};
+
+export { deleteHandler };

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

@@ -0,0 +1,34 @@
+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(({ url }) => {
+        downloadFromUrl(key, url.toString());
+        return { status: 'COMPLETE', value: { url } };
+    })
+        .catch(({ message }) => ({ message, status: 'FAILED' }));
+    return { result };
+};
+
+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, when from
+    // filtered from `results` by `parseResult`, creates a scenario where the
+    // return count of `results` is one item less than the provided `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 };