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

package/dist/esm/components/StorageBrowser/providers/store/files/utils.mjs

@@ -0,0 +1,52 @@
+import { isUndefined, isString, isEmpty } from '@aws-amplify/ui';
+
+const compareFileItems = (prev, next) => prev.key.localeCompare(next.key);
+const resolveFiles = (prevItems, files) => {
+    if (!files?.length)
+        return prevItems;
+    // construct `nextItems` and filter out existing `file` entries
+    const nextItems = files.reduce((items, file) => {
+        const { name, webkitRelativePath } = file;
+        return prevItems.some(({ file: existing }) => existing.name === name &&
+            existing.webkitRelativePath === webkitRelativePath)
+            ? items
+            : items.concat({
+                key: isEmpty(webkitRelativePath) ? name : webkitRelativePath,
+                id: crypto.randomUUID(),
+                file,
+            });
+    }, []);
+    if (!nextItems.length)
+        return prevItems;
+    if (!prevItems.length) {
+        return nextItems.sort(compareFileItems);
+    }
+    return prevItems.concat(nextItems).sort(compareFileItems);
+};
+const filesReducer = (prevItems, input) => {
+    switch (input.type) {
+        case 'ADD_FILE_ITEMS': {
+            return resolveFiles(prevItems, input.files);
+        }
+        case 'REMOVE_FILE_ITEM': {
+            const filteredItems = prevItems.filter(({ id }) => id !== input.id);
+            return filteredItems.length === prevItems.length
+                ? prevItems
+                : filteredItems;
+        }
+        case 'RESET_FILE_ITEMS': {
+            return [];
+        }
+        // TODO: clear message
+    }
+};
+const parseFileSelectParams = (value) => {
+    if (isUndefined(value))
+        return ['FILE', undefined];
+    if (isString(value))
+        return [value, undefined];
+    const [selectType, ...rest] = value;
+    return [selectType, !rest?.length ? undefined : { accept: rest.join() }];
+};
+
+export { filesReducer, parseFileSelectParams, resolveFiles };

package/dist/esm/components/StorageBrowser/providers/store/location/context.mjs

@@ -0,0 +1,49 @@
+import React__default from 'react';
+import { createContextUtilities } from '@aws-amplify/ui-react-core';
+import { noop } from '@aws-amplify/ui';
+import { assertLocationData } from '../../../validators/assertLocationData.mjs';
+
+const ERROR_MESSAGE = 'Invalid `location` value provided as initial value to `LocationProvider.';
+const DEFAULT_STATE = {
+    current: undefined,
+    path: '',
+    key: '',
+};
+function handleAction(state, action) {
+    switch (action.type) {
+        case 'NAVIGATE': {
+            const { location, path = '' } = action;
+            if (state.current?.id === location.id && state.path === path) {
+                return state;
+            }
+            return {
+                current: location,
+                path,
+                key: `${location.prefix ?? ''}${path}`,
+            };
+        }
+        case 'RESET_LOCATION': {
+            return DEFAULT_STATE;
+        }
+    }
+}
+const defaultValue = [DEFAULT_STATE, noop];
+const { LocationContext, useLocation } = createContextUtilities({
+    contextName: 'Location',
+    defaultValue,
+});
+function LocationProvider({ children, location, path = '', }) {
+    if (location) {
+        assertLocationData(location, ERROR_MESSAGE);
+    }
+    const value = React__default.useReducer(handleAction, location
+        ? {
+            current: location,
+            path,
+            key: `${location.prefix ?? ''}${path}`,
+        }
+        : DEFAULT_STATE);
+    return (React__default.createElement(LocationContext.Provider, { value: value }, children));
+}
+
+export { DEFAULT_STATE, ERROR_MESSAGE, LocationContext, LocationProvider, useLocation };

package/dist/esm/components/StorageBrowser/providers/store/locationItems/context.mjs

@@ -0,0 +1,52 @@
+import React__default from 'react';
+import { createContextUtilities } from '@aws-amplify/ui-react-core';
+import { noop } from '@aws-amplify/ui';
+import '@aws-amplify/storage/internals';
+import { createFileDataItem } from '../../../actions/handlers/utils.mjs';
+import 'aws-amplify/storage';
+import '../../../actions/configs/context.mjs';
+
+const DEFAULT_STATE = {
+    fileDataItems: undefined,
+};
+const locationItemsReducer = (prevState, event) => {
+    switch (event.type) {
+        case 'SET_LOCATION_ITEMS': {
+            const { items } = event;
+            if (!items?.length)
+                return prevState;
+            if (!prevState.fileDataItems?.length) {
+                return { fileDataItems: items.map(createFileDataItem) };
+            }
+            const nextFileDataItems = items?.reduce((fileDataItems, data) => prevState.fileDataItems?.some(({ id }) => id === data.id)
+                ? fileDataItems
+                : fileDataItems.concat(createFileDataItem(data)), []);
+            if (!nextFileDataItems?.length)
+                return prevState;
+            return {
+                fileDataItems: prevState.fileDataItems.concat(nextFileDataItems),
+            };
+        }
+        case 'REMOVE_LOCATION_ITEM': {
+            const { id } = event;
+            if (!prevState.fileDataItems)
+                return prevState;
+            const fileDataItems = prevState.fileDataItems.filter((item) => item.id !== id);
+            if (fileDataItems.length === prevState.fileDataItems.length) {
+                return prevState;
+            }
+            return { fileDataItems };
+        }
+        case 'RESET_LOCATION_ITEMS': {
+            return DEFAULT_STATE;
+        }
+    }
+};
+const defaultValue = [DEFAULT_STATE, noop];
+const { LocationItemsContext, useLocationItems } = createContextUtilities({ contextName: 'LocationItems', defaultValue });
+function LocationItemsProvider({ children, }) {
+    const value = React__default.useReducer(locationItemsReducer, DEFAULT_STATE);
+    return (React__default.createElement(LocationItemsContext.Provider, { value: value }, children));
+}
+
+export { DEFAULT_STATE, LocationItemsContext, LocationItemsProvider, useLocationItems };

package/dist/esm/components/StorageBrowser/providers/store/useStore.mjs

@@ -0,0 +1,47 @@
+import React__default from 'react';
+import { useActionType } from './actionType/context.mjs';
+import { useFiles } from './files/context.mjs';
+import { useLocation } from './location/context.mjs';
+import { useLocationItems } from './locationItems/context.mjs';
+
+function useStore() {
+    const [actionType, dispatchActionType] = useActionType();
+    const [files, dispatchFilesAction] = useFiles();
+    const [location, dispatchLocationAction] = useLocation();
+    const [locationItems, dispatchLocationItemsAction] = useLocationItems();
+    const dispatchHandler = React__default.useCallback((action) => {
+        switch (action.type) {
+            case 'ADD_FILE_ITEMS':
+            case 'REMOVE_FILE_ITEM':
+            case 'SELECT_FILES':
+            case 'RESET_FILE_ITEMS': {
+                dispatchFilesAction(action);
+                break;
+            }
+            case 'NAVIGATE':
+            case 'RESET_LOCATION': {
+                dispatchLocationAction(action);
+                break;
+            }
+            case 'SET_LOCATION_ITEMS':
+            case 'REMOVE_LOCATION_ITEM':
+            case 'RESET_LOCATION_ITEMS': {
+                dispatchLocationItemsAction(action);
+                break;
+            }
+            case 'SET_ACTION_TYPE':
+            case 'RESET_ACTION_TYPE': {
+                dispatchActionType(action);
+                break;
+            }
+        }
+    }, [
+        dispatchActionType,
+        dispatchFilesAction,
+        dispatchLocationAction,
+        dispatchLocationItemsAction,
+    ]);
+    return [{ actionType, files, location, locationItems }, dispatchHandler];
+}
+
+export { useStore };

package/dist/esm/components/StorageBrowser/tasks/constants.mjs

@@ -0,0 +1,11 @@
+const INITIAL_STATUS_COUNTS = {
+    CANCELED: 0,
+    COMPLETE: 0,
+    FAILED: 0,
+    PENDING: 0,
+    OVERWRITE_PREVENTED: 0,
+    QUEUED: 0,
+    TOTAL: 0,
+};
+
+export { INITIAL_STATUS_COUNTS };

package/dist/esm/components/StorageBrowser/tasks/useProcessTasks.mjs

@@ -0,0 +1,171 @@
+import React__default from 'react';
+import { isFunction } from '@aws-amplify/ui';
+import { getStatusCounts, isProcessingTasks, hasCompletedProcessingTasks } from './utils.mjs';
+
+const QUEUED_TASK_BASE = {
+    cancel: undefined,
+    message: undefined,
+    progress: undefined,
+    status: 'QUEUED',
+};
+const isTaskHandlerInput = (input) => !!input.data;
+const useProcessTasks = (handler, items, options) => {
+    const { concurrency, ...callbacks } = options ?? {};
+    const callbacksRef = React__default.useRef(callbacks);
+    if (callbacks) {
+        callbacksRef.current = callbacks;
+    }
+    const tasksRef = React__default.useRef(new Map());
+    const flush = React__default.useReducer(() => ({}), {})[1];
+    const refreshTaskData = React__default.useCallback((id, data) => {
+        const task = tasksRef.current.get(id);
+        if (!task || task.data.id !== data.id)
+            return;
+        tasksRef.current.set(id, { ...task, data });
+    }, []);
+    const updateTask = React__default.useCallback((id, next) => {
+        const { onTaskRemove } = callbacksRef.current;
+        const task = tasksRef.current.get(id);
+        if (!task)
+            return;
+        if (!next) {
+            onTaskRemove?.(task);
+            tasksRef.current.delete(id);
+        }
+        else {
+            tasksRef.current.set(id, { ...task, ...next });
+        }
+        flush();
+    }, [flush]);
+    const createTask = React__default.useCallback((data) => {
+        const getTask = () => tasksRef.current.get(data.id);
+        const { onTaskCancel } = callbacksRef.current;
+        function cancel() {
+            const task = getTask();
+            if (!task || task?.status !== 'QUEUED')
+                return;
+            if (task && isFunction(onTaskCancel))
+                onTaskCancel(task);
+            updateTask(data.id, { cancel: undefined, status: 'CANCELED' });
+        }
+        const task = { ...QUEUED_TASK_BASE, cancel, data };
+        tasksRef.current.set(data.id, task);
+    }, [updateTask]);
+    React__default.useEffect(() => {
+        // Sync tasks with items by first creating a lookup of current tasks
+        const taskLookup = {};
+        tasksRef.current.forEach(({ data }) => {
+            taskLookup[data.id] = true;
+        });
+        items?.forEach((item) => {
+            if (!taskLookup[item.id]) {
+                // If an item doesn't yet have a task created for it, create one
+                createTask(item);
+            }
+            else {
+                refreshTaskData(item.id, item);
+            }
+            // Remove the item from the lookup to mark it as "synced"
+            delete taskLookup[item.id];
+        });
+        // Remaining tasks are items which have been removed from state but not yet from tasks, so they should be removed
+        Object.keys(taskLookup).forEach((taskId) => {
+            // This should not happen, but if the task is pending then it cannot be removed
+            if (tasksRef.current.get(taskId)?.status === 'PENDING')
+                return;
+            updateTask(taskId);
+        });
+        flush();
+    }, [createTask, flush, updateTask, items, refreshTaskData]);
+    const processNextTask = (_input) => {
+        const hasInputData = isTaskHandlerInput(_input);
+        if (hasInputData) {
+            createTask(_input.data);
+            flush();
+        }
+        const { data } = hasInputData
+            ? _input
+            : [...tasksRef.current.values()].find(({ status }) => status === 'QUEUED') ?? {};
+        if (!data)
+            return;
+        const { onTaskCancel, onTaskComplete, onTaskError, onTaskProgress, onTaskSuccess, } = callbacksRef.current;
+        const getTask = () => tasksRef.current.get(data.id);
+        const { options } = _input;
+        const { onProgress: _onProgress, onSuccess, onError } = options ?? {};
+        const onProgress = ({ id }, progress) => {
+            const task = getTask();
+            if (task && isFunction(onTaskProgress)) {
+                onTaskProgress(task, progress);
+            }
+            if (task && isFunction(_onProgress)) {
+                _onProgress(data, progress);
+            }
+            updateTask(id, { progress });
+        };
+        const input = { ..._input, data, options: { ...options, onProgress } };
+        const { cancel: _cancel, result } = handler(input);
+        const cancel = !_cancel
+            ? undefined
+            : () => {
+                const task = getTask();
+                if (task && isFunction(onTaskCancel))
+                    onTaskCancel(task);
+                _cancel();
+            };
+        result
+            .then((output) => {
+            const task = getTask();
+            if (task && isFunction(onTaskSuccess)) {
+                onTaskSuccess(task, output?.value);
+            }
+            if (task && isFunction(onSuccess))
+                onSuccess(data, output?.value);
+            updateTask(data.id, output);
+        })
+            .catch((e) => {
+            const task = getTask();
+            if (task && isFunction(onTaskError))
+                onTaskError(task, e);
+            if (task && isFunction(onError))
+                onError(data, e?.message);
+            updateTask(data.id, { message: e.message, status: 'FAILED' });
+        })
+            .finally(() => {
+            const task = getTask();
+            if (task && isFunction(onTaskComplete))
+                onTaskComplete(task);
+            // ignore process next task for single operation inputs
+            if (hasInputData)
+                return;
+            processNextTask(_input);
+        });
+        updateTask(data.id, { cancel, status: 'PENDING' });
+    };
+    const tasks = [...tasksRef.current.values()];
+    const statusCounts = getStatusCounts(tasks);
+    const isProcessing = isProcessingTasks(statusCounts);
+    const isProcessingComplete = hasCompletedProcessingTasks(statusCounts);
+    const handleProcessTasks = (input) => {
+        if (isProcessing) {
+            return;
+        }
+        if (!concurrency) {
+            processNextTask(input);
+            return;
+        }
+        let count = 0;
+        while (count < concurrency) {
+            processNextTask(input);
+            count++;
+        }
+    };
+    const reset = () => {
+        tasks.forEach(({ data }) => updateTask(data.id));
+    };
+    return [
+        { isProcessing, isProcessingComplete, reset, statusCounts, tasks },
+        handleProcessTasks,
+    ];
+};
+
+export { useProcessTasks };

package/dist/esm/components/StorageBrowser/tasks/utils.mjs

@@ -0,0 +1,16 @@
+import { INITIAL_STATUS_COUNTS } from './constants.mjs';
+
+const getStatusCounts = (tasks = []) => tasks.reduce((counts, { status }) => ({ ...counts, [status]: counts[status] + 1 }), { ...INITIAL_STATUS_COUNTS, TOTAL: tasks.length });
+const isProcessingTasks = (statusCounts) => {
+    if (statusCounts.TOTAL === 0 || statusCounts.TOTAL === statusCounts.QUEUED) {
+        return false;
+    }
+    return !(statusCounts.QUEUED === 0 && statusCounts.PENDING === 0);
+};
+const hasCompletedProcessingTasks = (statusCounts) => {
+    if (statusCounts.TOTAL === 0 || isProcessingTasks(statusCounts))
+        return false;
+    return statusCounts.QUEUED === 0 && statusCounts.PENDING === 0;
+};
+
+export { getStatusCounts, hasCompletedProcessingTasks, isProcessingTasks };

package/dist/esm/components/StorageBrowser/useAction/constants.mjs

@@ -0,0 +1,4 @@
+const DEFAULT_ACTION_CONCURRENCY = 4;
+const USE_LIST_ERROR_MESSAGE = '`useList` must be called from within `StorageBrowser.Provider`';
+
+export { DEFAULT_ACTION_CONCURRENCY, USE_LIST_ERROR_MESSAGE };

package/dist/esm/components/StorageBrowser/useAction/context.mjs

@@ -0,0 +1,8 @@
+import { createContextUtilities } from '@aws-amplify/ui-react-core';
+
+const { ActionHandlersProvider, useActionHandlers } = createContextUtilities({
+    contextName: 'ActionHandlers',
+    errorMessage: '`useActionHandlers` must be called from within an `ActionHandlersProvider',
+});
+
+export { ActionHandlersProvider, useActionHandlers };

package/dist/esm/components/StorageBrowser/useAction/createEnhancedListHandler.mjs

@@ -0,0 +1,123 @@
+const SEARCH_LIMIT = 10000;
+const SEARCH_PAGE_SIZE = 1000;
+/**
+ * Normalizes and converts a string to lower case,
+ * handling Unicode characters and locale-specific case mappings.
+ * Uses NFKD to fully decompose unicode: https://unicode.org/reports/tr15/#Normalization_Forms_Table
+ */
+function normalize(input) {
+    return input
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '') // remove diacritic modifiers
+        .toLocaleLowerCase();
+}
+/**
+ * Performs a case-insensitive check to determine if a string includes another string,
+ * handling Unicode characters and locale-specific case mappings.
+ *
+ * @param {string} input - The string to search within.
+ * @param {string} query - The substring to search for.
+ * @returns {boolean} - Returns `true` if `query` is found in `input` (case-insensitively), otherwise `false`.
+ *
+ * @example
+ * caseInsensitiveIncludes("Photos", "photo"); // true
+ * caseInsensitiveIncludes("Hello", "HELLO");   // true
+ * caseInsensitiveIncludes("\uFB00", "\u0046\u0046");   // ff = FF true
+ * caseInsensitiveIncludes("Cafè", "cafe");   // true
+ */
+function caseInsensitiveIncludes(input, query) {
+    return normalize(input).includes(normalize(query));
+}
+function searchItems({ prefix = '', list, options }) {
+    const { query, filterBy, groupBy } = options;
+    // filter keys that match `filterBy` search option
+    const filteredItems = list.filter((item) => {
+        const key = typeof filterBy === 'function' ? filterBy(item) : filterBy;
+        const path = item[key];
+        const suffix = path.slice(prefix.length);
+        return caseInsensitiveIncludes(suffix, query);
+    });
+    if (!groupBy) {
+        return filteredItems;
+    }
+    // group items using the provided grouping delimiter
+    const uniquePaths = new Map();
+    for (const item of filteredItems) {
+        const key = typeof filterBy === 'function' ? filterBy(item) : filterBy;
+        const path = item[key];
+        const components = path.split(groupBy);
+        for (const [i, component] of components.entries()) {
+            if (!caseInsensitiveIncludes(component, query)) {
+                continue;
+            }
+            // list of components ending with match
+            const matchedPathSegments = components.slice(0, i + 1);
+            // create new path
+            let matchedPath = matchedPathSegments.join(groupBy);
+            const isFolder = matchedPath !== path;
+            if (isFolder) {
+                matchedPath += groupBy;
+            }
+            // ignore anything below the prefix for matching
+            if (matchedPath.length > prefix.length && !uniquePaths.has(matchedPath)) {
+                // add a new item
+                uniquePaths.set(matchedPath, {
+                    ...item,
+                    id: crypto.randomUUID(),
+                    [key]: matchedPath,
+                    type: isFolder ? 'FOLDER' : 'FILE',
+                });
+            }
+        }
+    }
+    return Array.from(uniquePaths.values());
+}
+const createEnhancedListHandler = (action) => {
+    return async function listActionHandler(prevState, { options, ...input }) {
+        const { nextToken: _nextToken, refresh, reset, search, ...rest } = options ?? {};
+        if (reset) {
+            return { items: [], nextToken: undefined };
+        }
+        // collect and filter results on `search`
+        if (search) {
+            const result = [];
+            let nextNextToken = undefined;
+            do {
+                const output = (await action({
+                    ...input,
+                    options: {
+                        ...rest,
+                        pageSize: SEARCH_PAGE_SIZE,
+                        nextToken: nextNextToken,
+                    },
+                }));
+                result.push(...output.items);
+                nextNextToken = output.nextToken;
+            } while (nextNextToken && result.length < SEARCH_LIMIT);
+            return {
+                items: searchItems({
+                    list: result,
+                    prefix: input.prefix,
+                    options: search,
+                }),
+                search: {
+                    // search limit reached but we still have a next token
+                    hasExhaustedSearch: !!nextNextToken,
+                },
+                nextToken: undefined,
+            };
+        }
+        // ignore provided `nextToken` on `refresh`
+        const nextToken = refresh ? undefined : _nextToken;
+        const output = (await action({
+            ...input,
+            options: { ...rest, nextToken },
+        }));
+        return {
+            items: [...(refresh ? [] : prevState.items), ...output.items],
+            nextToken: output.nextToken,
+        };
+    };
+};
+
+export { SEARCH_LIMIT, SEARCH_PAGE_SIZE, createEnhancedListHandler, searchItems };

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

@@ -0,0 +1,18 @@
+import { useActionHandlers } from './context.mjs';
+import { useHandler } from './useHandler.mjs';
+
+const ERROR_MESSAGE = '`useAction` must be called from within `StorageBrowser.Provider`';
+const useAction = (key, options) => {
+    if (key === 'listLocations' ||
+        key === 'listLocationItems') {
+        throw new Error(`Value of \`${key}\` cannot be used to index \`useAction\``);
+    }
+    const { handlers } = useActionHandlers({ errorMessage: ERROR_MESSAGE });
+    const handler = handlers[key];
+    if (!handler) {
+        throw new Error(`No handler found for value of \`${key}\` provided to \`useAction\``);
+    }
+    return useHandler(handler, options);
+};
+
+export { ERROR_MESSAGE, useAction };

package/dist/esm/components/StorageBrowser/useAction/useHandler.mjs

@@ -0,0 +1,40 @@
+import React__default from 'react';
+import { isObject } from '@aws-amplify/ui';
+import { useGetActionInput } from '../providers/configuration/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';
+
+const isTasksOptions = (value) => isObject(value);
+const useHandler = (action, options) => {
+    const hasOptions = isTasksOptions(options);
+    const { items, onTaskSuccess } = options ?? {};
+    const getConfig = useGetActionInput();
+    const { location: { current }, } = useStore()[0];
+    const [state, processTask] = useProcessTasks(action, items, {
+        onTaskSuccess,
+        ...(items ? { concurrency: DEFAULT_ACTION_CONCURRENCY } : undefined),
+    });
+    const { reset, isProcessing, tasks } = state;
+    const handler = React__default.useCallback((input) => {
+        const { location } = input ?? {};
+        const config = getConfig(location ?? current);
+        if (!hasOptions) {
+            // clean up previous state
+            reset();
+            processTask({ ...input, config });
+            return;
+        }
+        processTask({ config });
+    }, [current, getConfig, hasOptions, processTask, reset]);
+    return [
+        hasOptions ? state : { isProcessing, task: tasks?.[0] },
+        handler,
+    ];
+};
+
+export { useHandler };

package/dist/esm/components/StorageBrowser/useAction/useList.mjs

@@ -0,0 +1,19 @@
+import { useListLocations } from './useListLocations.mjs';
+import { useListLocationItems } from './useListLocationItems.mjs';
+import { useListFolderItems } from './useListFolderItems.mjs';
+
+const LIST_ACTION_HOOKS = {
+    folderItems: useListFolderItems,
+    locationItems: useListLocationItems,
+    locations: useListLocations,
+};
+const isListActionViewType = (value) => Object.keys(LIST_ACTION_HOOKS).includes(value);
+// @ts-expect-error
+const useList = (type) => {
+    if (!isListActionViewType(type)) {
+        throw new Error(`Value of \`${type}\` cannot be used to index \`useList\``);
+    }
+    return LIST_ACTION_HOOKS[type]();
+};
+
+export { useList };

package/dist/esm/components/StorageBrowser/useAction/useListFolderItems.mjs

@@ -0,0 +1,23 @@
+import React__default from 'react';
+import { useDataState } from '@aws-amplify/ui-react-core';
+import { USE_LIST_ERROR_MESSAGE } from './constants.mjs';
+import { useActionHandlers } from './context.mjs';
+import { createEnhancedListHandler } from './createEnhancedListHandler.mjs';
+import '@aws-amplify/ui-react-core/elements';
+import '../providers/configuration/credentials/context.mjs';
+import { useGetActionInput } from '../providers/configuration/context.mjs';
+
+const useListFolderItems = () => {
+    const { handlers } = useActionHandlers({
+        errorMessage: USE_LIST_ERROR_MESSAGE,
+    });
+    const getConfig = useGetActionInput();
+    const { listLocationItems } = handlers;
+    const enhancedHandler = React__default.useMemo(() => createEnhancedListHandler((input) => listLocationItems({ ...input, config: getConfig() })), [getConfig, listLocationItems]);
+    return useDataState(enhancedHandler, {
+        items: [],
+        nextToken: undefined,
+    });
+};
+
+export { useListFolderItems };

package/dist/esm/components/StorageBrowser/useAction/useListLocationItems.mjs

@@ -0,0 +1,23 @@
+import React__default from 'react';
+import { useDataState } from '@aws-amplify/ui-react-core';
+import '@aws-amplify/ui-react-core/elements';
+import '../providers/configuration/credentials/context.mjs';
+import { useGetActionInput } from '../providers/configuration/context.mjs';
+import { USE_LIST_ERROR_MESSAGE } from './constants.mjs';
+import { useActionHandlers } from './context.mjs';
+import { createEnhancedListHandler } from './createEnhancedListHandler.mjs';
+
+const useListLocationItems = () => {
+    const { handlers } = useActionHandlers({
+        errorMessage: USE_LIST_ERROR_MESSAGE,
+    });
+    const getConfig = useGetActionInput();
+    const { listLocationItems } = handlers;
+    const enhancedHandler = React__default.useMemo(() => createEnhancedListHandler((input) => listLocationItems({ ...input, config: getConfig() })), [getConfig, listLocationItems]);
+    return useDataState(enhancedHandler, {
+        items: [],
+        nextToken: undefined,
+    });
+};
+
+export { useListLocationItems };