@aws-amplify/ui-react-storage 3.9.1 → 3.10.0

package/dist/types/components/StorageBrowser/credentials/credentialsStore/types.d.ts

@@ -0,0 +1,44 @@
+import { LocationPermissions } from '../../actions';
+import { AWSTemporaryCredentials, LocationCredentialsProvider, LocationCredentials } from '../../storage-internal';
+export interface CredentialsLocation {
+    scope: string;
+    permissions: LocationPermissions;
+}
+export interface CreateLocationCredentialsStoreInput {
+    handler: GetLocationCredentials;
+}
+export interface LocationCredentialsStore {
+    /**
+     * Get location-specific credentials. It uses a cache internally to optimize performance when
+     * getting credentials for the same location. It will refresh credentials if they expire or
+     * when forced to.
+     */
+    getProvider(option: CredentialsLocation): LocationCredentialsProvider;
+    /**
+     * Invalidate cached credentials and force subsequent calls to get location-specific
+     * credentials to throw. It also makes subsequent calls to `getCredentialsProviderForLocation`
+     * to throw.
+     */
+    destroy(): void;
+}
+export type GetLocationCredentialsInput = CredentialsLocation;
+export type GetLocationCredentialsOutput = LocationCredentials;
+export type GetLocationCredentials = (input: GetLocationCredentialsInput) => Promise<GetLocationCredentialsOutput>;
+export interface CredentialsStoreValue extends CredentialsLocation {
+    credentials?: AWSTemporaryCredentials;
+    inflightCredentials?: Promise<{
+        credentials: AWSTemporaryCredentials;
+    }>;
+}
+export type CacheKey = `${string}_${string}`;
+/**
+ * LRU implementation for Location Credentials Store
+ * O(n) for get and set for simplicity.
+ *
+ * @internal
+ */
+export interface LruLocationCredentialsStore {
+    capacity: number;
+    refreshHandler: GetLocationCredentials;
+    values: Map<CacheKey, CredentialsStoreValue>;
+}

package/dist/types/components/StorageBrowser/credentials/index.d.ts

@@ -0,0 +1,3 @@
+export { CredentialsProvider, useCredentials } from './context';
+export { createLocationCredentialsStore, GetLocationCredentials, GetLocationCredentialsInput, CredentialsLocation, CreateLocationCredentialsStoreInput, LocationCredentialsStore, } from './credentialsStore';
+export { CredentialsProviderProps, GetCredentials, RegisterAuthListener, } from './types';

package/dist/types/components/StorageBrowser/credentials/types.d.ts

@@ -1,26 +1,20 @@
+import React from 'react';
 import { LocationPermissions } from '../actions';
-import { LocationCredentialsProvider, LocationCredentials } from '../storage-internal';
-export interface CredentialsLocation {
+import { LocationCredentialsProvider } from '../storage-internal';
+import { CreateLocationCredentialsStoreInput, GetLocationCredentials, LocationCredentialsStore } from './credentialsStore';
+export type RegisterAuthListener = (onStateChange: () => void) => void;
+export type GetCredentials = (input: {
     scope: string;
     permissions: LocationPermissions;
+}) => LocationCredentialsProvider;
+export interface CredentialsStore extends Omit<LocationCredentialsStore, 'getProvider'> {
+    getCredentials: GetCredentials;
 }
-export interface CreateLocationCredentialsStoreInput {
-    handler: GetLocationCredentials;
+export interface CreateCredentialsStoreInput extends CreateLocationCredentialsStoreInput {
 }
-export interface LocationCredentialsStore {
-    /**
-     * Get location-specific credentials. It uses a cache internally to optimize performance when
-     * getting credentials for the same location. It will refresh credentials if they expire or
-     * when forced to.
-     */
-    getProvider(option: CredentialsLocation): LocationCredentialsProvider;
-    /**
-     * Invalidate cached credentials and force subsequent calls to get location-specific
-     * credentials to throw. It also makes subsequent calls to `getCredentialsProviderForLocation`
-     * to throw.
-     */
-    destroy(): void;
+export interface CredentialsProviderProps {
+    children?: React.ReactNode;
+    getLocationCredentials: GetLocationCredentials;
+    onDestroy?: () => void;
+    registerAuthListener: RegisterAuthListener;
 }
-export type GetLocationCredentialsInput = CredentialsLocation;
-export type GetLocationCredentialsOutput = LocationCredentials;
-export type GetLocationCredentials = (input: GetLocationCredentialsInput) => Promise<GetLocationCredentialsOutput>;

package/dist/types/components/StorageBrowser/{providers/configuration/credentials → credentials}/useCredentialsStore.d.ts

@@ -1,5 +1,5 @@
+import { GetLocationCredentials } from './credentialsStore';
 import { CredentialsStore, RegisterAuthListener } from './types';
-import { GetLocationCredentials } from '../../../credentials/types';
 export declare function useCredentialsStore({ getLocationCredentials: handler, initialValue, onDestroy, registerAuthListener, }: {
     getLocationCredentials: GetLocationCredentials;
     initialValue?: CredentialsStore;

package/dist/types/components/StorageBrowser/displayText/index.d.ts

@@ -1,3 +1,4 @@
 export { DisplayTextProvider, useDisplayText } from './context';
 export { DEFAULT_STORAGE_BROWSER_DISPLAY_TEXT as DefaultStorageBrowserDisplayText } from './libraries';
 export { LocationDetailViewDisplayText, LocationsViewDisplayText, CreateFolderViewDisplayText, CopyViewDisplayText, UploadViewDisplayText, DeleteViewDisplayText, StorageBrowserDisplayText, } from './types';
+export { isCopyViewDisplayTextKey, isDeleteViewDisplayTextKey } from './utils';

package/dist/types/components/StorageBrowser/displayText/types.d.ts

@@ -1,8 +1,8 @@
-import { StatusCounts, Tasks } from '../tasks';
+import { StatusCounts, Task } from '../tasks';
 import { CopyHandlerData, CreateFolderHandlerData, DeleteHandlerData, FolderData, LocationData, LocationItemData, TaskData, UploadHandlerData, LocationPermissions } from '../actions';
-import { LocationState } from '../providers/store/location';
-import { MessageType } from '../composables/Message';
-import { FileItems } from '../providers';
+import { MessageType } from '../components';
+import { FileItems } from '../files';
+import { LocationState } from '../store';
 /**
  * Common list view display text values
  */
@@ -67,7 +67,7 @@ export interface DefaultActionViewDisplayText<T extends TaskData = TaskData> {
     actionStartLabel: string;
     getActionCompleteMessage: (data?: {
         counts?: StatusCounts;
-        tasks?: Tasks<T>;
+        tasks?: Task<T>[];
     }) => {
         content?: string;
         type?: MessageType;
@@ -85,7 +85,6 @@ export interface DefaultActionViewDisplayText<T extends TaskData = TaskData> {
     tableColumnNameHeader: string;
     tableColumnTypeHeader: string;
     tableColumnSizeHeader: string;
-    tableColumnProgressHeader: string;
 }
 export interface DefaultCreateFolderViewDisplayText extends Omit<DefaultActionViewDisplayText<CreateFolderHandlerData>, `${'tableColumn' | 'statusDisplay'}${string}`> {
     folderNameLabel: string;
@@ -105,20 +104,29 @@ export interface DefaultCopyViewDisplayText extends DefaultActionViewDisplayText
     searchPlaceholder: string;
     searchSubmitLabel: string;
     searchClearLabel: string;
+    /**
+     * @deprecated `CopyView` does not render a "progress" header
+     */
+    tableColumnProgressHeader?: string;
 }
 export interface DefaultDeleteViewDisplayText extends DefaultActionViewDisplayText<DeleteHandlerData> {
+    /**
+     * @deprecated `DeleteView` does not render a "progress" header
+     */
+    tableColumnProgressHeader?: string;
 }
 export interface DefaultUploadViewDisplayText extends DefaultActionViewDisplayText<UploadHandlerData> {
     addFilesLabel: string;
     addFolderLabel: string;
-    statusDisplayOverwritePreventedLabel: string;
-    overwriteToggleLabel: string;
     getFilesValidationMessage: (data?: {
         invalidFiles?: FileItems;
     }) => {
         content?: string;
         type?: MessageType;
     } | undefined;
+    overwriteToggleLabel: string;
+    statusDisplayOverwritePreventedLabel: string;
+    tableColumnProgressHeader: string;
 }
 export interface DefaultStorageBrowserDisplayText {
     CopyView: DefaultCopyViewDisplayText;
@@ -140,6 +148,9 @@ export interface LocationDetailViewDisplayText extends Partial<DefaultLocationDe
 }
 export interface UploadViewDisplayText extends Partial<DefaultUploadViewDisplayText> {
 }
+/**
+ * `StorageBrowser` display text strings/resolver functions
+ */
 export interface StorageBrowserDisplayText {
     LocationsView?: LocationsViewDisplayText;
     LocationDetailView?: LocationDetailViewDisplayText;

package/dist/types/components/StorageBrowser/displayText/utils.d.ts

@@ -0,0 +1,3 @@
+import { CopyViewDisplayText, DeleteViewDisplayText } from './types';
+export declare const isCopyViewDisplayTextKey: (value: string) => value is keyof CopyViewDisplayText;
+export declare const isDeleteViewDisplayTextKey: (value: string) => value is keyof DeleteViewDisplayText;

package/dist/types/components/StorageBrowser/{providers/store/files → files}/types.d.ts

@@ -1,4 +1,4 @@
-import { LocationItemType, TaskData } from '../../../actions';
+import { FileItem, LocationItemType } from '../actions';
 /**
  * native OS file picker type. to restrict selectable file types, define the picker types
  * followed by accepted file types as strings
@@ -21,9 +21,6 @@ export type FilesActionType = {
     type: 'RESET_FILE_ITEMS';
 };
 export type HandleFilesAction = (input: FilesActionType) => void;
-export interface FileItem extends TaskData {
-    file: File;
-}
 export type FileItems = FileItem[];
 export type FilesContextType = [FileItems | undefined, HandleFilesAction];
 export interface FilesProviderProps {

package/dist/types/components/StorageBrowser/index.d.ts

@@ -1,7 +1,7 @@
-export { componentsDefault } from './componentsDefault';
-export { createStorageBrowser } from './createStorageBrowser';
-export { ActionViewConfig, ActionHandler, FileDataItem, ExtendedActionConfigs, } from './actions';
+export { ActionHandler, ActionViewConfig, CopyHandlerInput, CopyHandlerOutput, CreateFolderHandlerInput, CreateFolderHandlerOutput, defaultActionConfigs, defaultHandlers, DefaultHandlers, DeleteHandlerInput, DeleteHandlerOutput, DownloadHandlerInput, DownloadHandlerOutput, ExtendedActionConfigs, ListLocations, ListLocationsInput, ListLocationsOutput, LocationData, ListLocationItemsHandlerInput, ListLocationItemsHandlerOutput, ListLocationsHandlerInput, ListLocationsHandlerOutput, UploadHandlerInput, UploadHandlerOutput, } from './actions';
 export { createAmplifyAuthAdapter, createManagedAuthAdapter, CreateManagedAuthAdapterInput, StorageBrowserAuthAdapter, } from './adapters';
-export { DefaultStorageBrowserDisplayText } from './displayText';
-export { CreateStorageBrowserInput, StorageBrowserType, DerivedActionViewType, DerivedActionViews, } from './types';
+export { componentsDefault, StorageBrowserComponents } from './components';
+export { createStorageBrowser, CreateStorageBrowserInput, CreateStorageBrowserOutput, DerivedActionViews, DerivedActionViewType, StorageBrowserConfig, StorageBrowserProps, StorageBrowserProviderProps, StorageBrowserType, } from './createStorageBrowser';
+export { DefaultStorageBrowserDisplayText, StorageBrowserDisplayText, } from './displayText';
+export { StorageBrowserEventValue, StorageBrowserValue } from './store';
 export { UseView } from './views';

package/dist/types/components/StorageBrowser/{providers/store/locationItems → locationItems}/context.d.ts

@@ -1,5 +1,5 @@
 import React from 'react';
-import { FileData, FileDataItem } from '../../../actions';
+import { FileData, FileDataItem } from '../actions';
 export declare const DEFAULT_STATE: LocationItemsState;
 export type LocationItemsAction = {
     type: 'SET_LOCATION_ITEMS';

package/dist/types/components/StorageBrowser/storage-internal.d.ts

@@ -1 +1 @@
-export { AWSTemporaryCredentials, CopyInput, CredentialsLocation, CredentialsProvider, GetUrlInput, ListLocations, ListLocationsOutput, ListOutput, ListPaginateInput, LocationAccess, LocationCredentials, LocationCredentialsProvider, Permission, RemoveInput, StorageAccess, StorageSubpathStrategy, StorageValidationErrorCode, UploadDataInput, ListPathsOutput, assertValidationError, copy, getDataAccess, getUrl, list, listCallerAccessGrants, listPaths, remove, uploadData, validationErrorMap, } from '@aws-amplify/storage/internals';
+export { AWSTemporaryCredentials, CopyInput, CopyOutput, CredentialsLocation, CredentialsProvider, GetUrlInput, ListLocations, ListLocationsOutput, ListOutput, ListPaginateInput, LocationAccess, LocationCredentials, LocationCredentialsProvider, Permission, RemoveInput, StorageAccess, StorageSubpathStrategy, StorageValidationErrorCode, UploadDataInput, ListPathsOutput, assertValidationError, copy, getDataAccess, getUrl, list, listCallerAccessGrants, listPaths, remove, uploadData, validationErrorMap, } from '@aws-amplify/storage/internals';

package/dist/types/components/StorageBrowser/store/constants.d.ts

@@ -0,0 +1,2 @@
+import { StoreState } from './types';
+export declare const DEFAULT_STATE: StoreState;

package/dist/types/components/StorageBrowser/store/context.d.ts

@@ -0,0 +1,6 @@
+import React from 'react';
+import { StoreProviderProps, StoreContextType } from './types';
+export declare const StoreContext: React.Context<StoreContextType>, useStore: (params?: {
+    errorMessage?: string | undefined;
+} | undefined) => StoreContextType;
+export declare function StoreProvider({ children, ...props }: StoreProviderProps): React.JSX.Element;

package/dist/types/components/StorageBrowser/store/index.d.ts

@@ -0,0 +1,2 @@
+export { StoreProvider, useStore } from './context';
+export { LocationEventValue, LocationState, LocationValue, StorageBrowserEventValue, StorageBrowserValue, StoreProviderProps, StoreState, } from './types';

package/dist/types/components/StorageBrowser/store/storeReducer.d.ts

@@ -0,0 +1,2 @@
+import { StoreActionType, StoreState } from './types';
+export default function storeReducer(state: StoreState, action: StoreActionType): StoreState;

package/dist/types/components/StorageBrowser/store/types.d.ts

@@ -0,0 +1,108 @@
+import React from 'react';
+import { LocationData, LocationType } from '../actions';
+/**
+ * @see {@link LocationData}
+ */
+export interface LocationValue extends Pick<LocationData, 'bucket' | 'permissions' | 'prefix'> {
+    /**
+     * @see {@link LocationData.id} defaults to auto-generated uuid
+     */
+    id?: LocationData['id'];
+    /**
+     * @description string following `location.prefix` in forming an object key. defaults to empty string
+     * @example
+     * ```ts
+     * const path = "my-path/my-nested-path/";
+     *
+     * const prefix = "my-prefix/";
+     * const bucket = "my-bucket";
+     *
+     * // "my-bucket/my-prefix/my-path/my-nested-path/"
+     * const key = `${bucket}/${prefix}${path}`
+     *```
+     */
+    path?: string;
+    /**
+     * @see {@link LocationType}
+     */
+    type?: LocationType;
+}
+export interface StorageBrowserValue {
+    actionType?: string;
+    location?: LocationValue;
+}
+export interface LocationEventValue extends Required<LocationValue> {
+}
+export interface StorageBrowserEventValue {
+    actionType: string | undefined;
+    location: LocationEventValue | undefined;
+}
+export interface StoreProviderProps {
+    children?: React.ReactNode;
+    defaultValue?: StorageBrowserValue | null;
+    value?: StorageBrowserValue | null;
+    onValueChange?: (event: StorageBrowserEventValue) => void;
+    /**
+     * @deprecated
+     */
+    actionType?: string;
+    /**
+     * @deprecated
+     */
+    location?: LocationData;
+    /**
+     * @deprecated
+     */
+    path?: string;
+}
+export type StoreActionType = {
+    type: 'CHANGE_ACTION_TYPE';
+    actionType: string;
+} | {
+    type: 'RESET_ACTION_TYPE';
+} | {
+    type: 'CHANGE_LOCATION';
+    location: LocationData;
+    path?: string;
+} | {
+    type: 'RESET_LOCATION';
+};
+/**
+ * Stores current `location` and nested `path` values set on
+ * navigate events.
+ *
+ * @example
+ *`"s3://my-bucket/my-prefix/a-path/a-nested-path/"`
+ *
+ * ```
+ * const state: LocationState = {
+ *   location: {
+ *     bucket: 'my-bucket',
+ *     permisson: 'READWRITE',
+ *     prefix: 'my/prefix/',
+ *     type: 'PREFIX',
+ *   },
+ *   path: 'a-path/a-nested-path/',
+ *   key: 'my/prefix/a-path/a-nested-path/',
+ * }
+ *
+ */
+export interface LocationState {
+    /**
+     * current `location` metadata
+     */
+    current: LocationData | undefined;
+    /**
+     * current `location` subpath within a `location`
+     */
+    path: string;
+    /**
+     * fully qualified string consisting of `location` prefix and path
+     */
+    key: string;
+}
+export interface StoreState {
+    actionType: string | undefined;
+    location: LocationState;
+}
+export type StoreContextType = [StoreState, React.Dispatch<StoreActionType>];

package/dist/types/components/StorageBrowser/store/useStoreReducer.d.ts

@@ -0,0 +1,2 @@
+import { StoreProviderProps, StoreContextType } from './types';
+export default function useStoreReducer(props: StoreProviderProps): StoreContextType;

package/dist/types/components/StorageBrowser/store/utils.d.ts

@@ -0,0 +1,6 @@
+import { LocationData } from '../actions';
+import { LocationValue, StorageBrowserValue, StoreProviderProps, StoreState } from './types';
+export declare const parseLocationType: ({ prefix, }: LocationData | LocationValue) => LocationData['type'];
+export declare function getLocationData(location?: LocationData | LocationValue): LocationData | undefined;
+export declare function getState(value: StorageBrowserValue | null | undefined): StoreState;
+export declare function getInitialState(defaultValue: StorageBrowserValue | null | undefined, legacyProps?: Pick<StoreProviderProps, 'actionType' | 'location' | 'path'>): StoreState;

package/dist/types/components/StorageBrowser/store/validateStoreProps.d.ts

@@ -0,0 +1,9 @@
+import { StoreProviderProps } from './types';
+export declare const CONLICTING_PROPS = "`StorageBrowser` has been been provided with both `value` and `defaultValue` props. StorageBrowser must be either controlled or uncontrolled (specify either the `value` prop, or the `defaultValue` prop, but not both). Decide between using a controlled or uncontrolled `StorageBrowser` and remove one of these props.";
+export declare const READONLY = "A `value` prop has been provided to `StorageBrowser` without `onValueChange`. This will render a read-only `StorageBrowser`. If the `StorageBrowser` should be mutable use `defaultValue`, otherwise set `onValueChange`.";
+export declare const MISSING_REQUIRED = "A `value` prop has been provided to `StorageBrowser` without all required `location` parameters. `StorageBrowser` will ignore the provided `location`. Missing `location` parameters: %s.";
+export declare const DEPRECATED_SUFFIX = "`actionType`, `location` and `path` props have been deprecated and will be removed in a future major version. Provide the `value` prop for controlled behavior or the `defaultValue` prop for uncontrolled behavior.";
+export declare const DEPRECATED_PROPS = "`StorageBrowser` has been provided with one or more deprecated props: %s. %s";
+export declare const DEPRECATED_PROPS_AND_CONFLICTING = "`StorageBrowser` has been provided with deprecated props of %s that conflict with the `value` and `defaultValue` props. %s";
+export declare const CHANGED_MODE = "`StorageBrowser` has changed from controlled to uncontrolled due to the `value` prop resolving to type `%s`. Switching between controlled and uncontrolled behaviors is not supported and may lead to unexpected behaviors.";
+export default function validateStoreProps(props: StoreProviderProps): void;

package/dist/types/components/StorageBrowser/tasks/index.d.ts

@@ -1,3 +1,3 @@
 export { INITIAL_STATUS_COUNTS } from './constants';
 export { useProcessTasks } from './useProcessTasks';
-export { StatusCounts, Task, Tasks, TaskStatus } from './types';
+export { ProcessTasksOptions, StatusCounts, Task, TaskStatus, TasksState, } from './types';

package/dist/types/components/StorageBrowser/tasks/types.d.ts

@@ -1,33 +1,51 @@
-import { TaskHandlerInput, TaskData } from '../actions';
-export type TaskStatus = 'CANCELED' | 'FAILED' | 'COMPLETE' | 'OVERWRITE_PREVENTED' | 'QUEUED' | 'PENDING';
+import { TaskHandlerInput, TaskData, TaskResult, TaskResultStatus } from '../actions';
+/**
+ * extends {@link TaskResultStatus} to include `QUEUED` and `PENDING` statuses
+ * used in task processing
+ */
+export type TaskStatus = TaskResultStatus | 'QUEUED' | 'PENDING';
+/**
+ * aggregate task status counts
+ */
 export type StatusCounts = Record<TaskStatus | 'TOTAL', number>;
-export interface ProcessTasksOptions<T extends TaskData = TaskData, V = any, U extends number | never = never> {
-    concurrency?: U;
-    onTaskCancel?: (data: Task<T>) => void;
-    onTaskComplete?: (data: Task<T>) => void;
-    onTaskError?: (data: Task<T>, error: Error | undefined) => void;
-    onTaskProgress?: (data: Task<T>, progress: number | undefined) => void;
-    onTaskSuccess?: (data: Task<T>, value: V | undefined) => void;
-    onTaskRemove?: (data: Task<T>) => void;
+export interface ProcessTasksOptions<TTask extends Task, TItems = []> {
+    concurrency?: number;
+    items?: TItems;
+    onTaskCancel?: (task: TTask) => void;
+    onTaskComplete?: (task: TTask) => void;
+    onTaskError?: (task: TTask, error: unknown) => void;
+    onTaskProgress?: (task: TTask, progress: number | undefined) => void;
+    onTaskSuccess?: (task: TTask, value: TTask['value'] | undefined) => void;
+    onTaskRemove?: (task: TTask) => void;
 }
-export interface Task<T extends TaskData = TaskData, V = any> {
-    data: T;
-    message: string | undefined;
-    progress: number | undefined;
-    status: TaskStatus;
+/**
+ * `task` properties, extends {@link TaskResult} with task data, optional cancel
+ * handler and progress
+ */
+export interface Task<TData = unknown, TValue = any> extends TaskResult<TaskStatus, TValue> {
+    /**
+     * task specific data
+     */
+    data: TData & TaskData;
+    /**
+     * task progress
+     */
+    progress?: number;
+    /**
+     * cancel handler
+     */
     cancel?: () => void;
-    value?: V;
 }
-export type Tasks<T extends TaskData, V = any> = Task<T, V>[];
-export type HandleProcessTasks<T extends TaskData, U> = (input: U extends T[] ? Omit<TaskHandlerInput<T>, 'data'> : TaskHandlerInput<T>) => void;
-export interface TasksState<T extends TaskData = TaskData> {
+export type HandleProcessTasks<TInput> = (input: TInput) => void;
+export interface TasksState<TTask> {
     isProcessing: boolean;
     isProcessingComplete: boolean;
     reset: () => void;
     statusCounts: StatusCounts;
-    tasks: Tasks<T>;
+    tasks: TTask[];
 }
-export type UseProcessTasksState<T extends TaskData, D> = [
-    TasksState<T>,
-    HandleProcessTasks<T, D>
+export type UseProcessTasksState<TTask, TInput> = [
+    TasksState<TTask>,
+    HandleProcessTasks<TInput>
 ];
+export type InferHandleTasksInput<TItems, TData extends TaskData> = TItems extends NonNullable<TItems> ? Omit<TaskHandlerInput<TData>, 'data'> : TaskHandlerInput<TData>;

package/dist/types/components/StorageBrowser/tasks/useProcessTasks.d.ts

@@ -1,3 +1,3 @@
-import { ActionHandler, TaskData } from '../actions';
-import { ProcessTasksOptions, UseProcessTasksState } from './types';
-export declare const useProcessTasks: <TData extends TaskData = TaskData, RValue = any, D extends TData[] | undefined = undefined>(handler: ActionHandler<TData, RValue>, items?: D | undefined, options?: ProcessTasksOptions<TData, RValue, D extends TData[] ? number : never> | undefined) => UseProcessTasksState<TData, D>;
+import { ActionHandler } from '../actions';
+import { InferHandleTasksInput, Task, ProcessTasksOptions, UseProcessTasksState } from './types';
+export declare function useProcessTasks<TData, TValue, TTask extends Task<TData, TValue>, TInput extends InferHandleTasksInput<TItems, TTask['data']>, TItems extends TTask['data'][] | undefined = undefined>(handler: ActionHandler<TData, TValue>, options?: ProcessTasksOptions<TTask, TItems>): UseProcessTasksState<TTask, TInput>;

package/dist/types/components/StorageBrowser/useAction/types.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { DataState } from '@aws-amplify/ui-react-core';
-import { ActionHandler, ExtendedActionConfigs, CopyHandler, CreateFolderHandler, DeleteHandler, DownloadHandler, ListLocationItemsHandler, ListLocations, LocationData, TaskData, UploadHandler } from '../actions';
-import { StatusCounts, Task, Tasks } from '../tasks';
+import { ActionHandler, ExtendedActionConfigs, CopyHandler, CreateFolderHandler, DeleteHandler, DownloadHandler, ListLocationItemsHandler, ListLocations, LocationData, UploadHandler } from '../actions';
+import { ProcessTasksOptions, StatusCounts, Task } from '../tasks';
 export type ListActionState<T = any, K = any> = [
     state: DataState<T>,
     handleAction: (...input: K[]) => void
@@ -29,48 +29,83 @@ export type ResolveHandlerType<T> = T extends {
 export type DerivedActionHandlers<C extends ExtendedActionConfigs = ExtendedActionConfigs, D extends DerivedCustomActions<C> = DerivedCustomActions<C>> = DefaultActionHandlers & {
     [K in keyof D]: ResolveHandlerType<D[K]>;
 };
-export interface HandleTasksOptions<U extends TaskData = TaskData> {
-    items: U[];
-    onTaskSuccess?: (task: Task<U>) => void;
+export type InferTask<THandler> = THandler extends ActionHandler<infer TData, infer TValue> ? Task<TData, TValue> : never;
+export interface UseHandlerOptions<TTask extends Task> extends Pick<ProcessTasksOptions<TTask>, 'onTaskError' | 'onTaskProgress' | 'onTaskSuccess'> {
 }
-interface HandleTasksInput {
-    location?: LocationData;
+export interface UseHandlerOptionsWithItems<TTask extends Task> extends UseHandlerOptions<TTask> {
+    items: TTask['data'][];
 }
-export interface HandleTaskInput<T, K> {
-    data: T;
+export interface HandleTasksInput {
     location?: LocationData;
-    options?: {
-        onSuccess?: (data: {
-            id: string;
-            key: string;
-        }, value: K) => void;
-        onError?: (data: {
-            id: string;
-            key: string;
-        }, message: string | undefined) => void;
-    };
 }
-export type HandlerInput<T extends TaskData, K, U = undefined> = U extends undefined ? HandleTaskInput<T, K> : HandleTasksInput;
-export interface TasksState<T extends TaskData, V = any> {
+export interface TasksState<TTask> {
     isProcessing: boolean;
     isProcessingComplete: boolean;
     reset: () => void;
     statusCounts: StatusCounts;
-    tasks: Tasks<T, V>;
+    tasks: TTask[];
 }
-export type HandleTasks = (input?: HandleTasksInput) => void;
-export type UseTasksState<T extends TaskData, V = any> = [
-    TasksState<T, V>,
-    HandleTasks
+export type HandleTasksState<TTask> = [
+    TasksState<TTask>,
+    (input?: HandleTasksInput) => void
 ];
-export type HandleTask<T, K> = (input: HandleTaskInput<T, K>) => void;
-export type UseTaskState<T extends TaskData, R> = [
+export type HandleTaskState<TTask extends Task> = [
     {
-        task: Task<T, R> | undefined;
+        task: TTask;
         isProcessing: boolean;
     },
-    HandleTask<T, R>
+    (input: HandleTaskInput<TTask['data']>) => void
+];
+export interface HandleTaskInput<TData> {
+    data: TData;
+    location?: LocationData;
+}
+export interface UseActionOptions<TTask extends Task> extends UseHandlerOptions<TTask> {
+}
+export interface UseActionOptionsWithItems<TTask extends Task> extends UseActionOptions<TTask> {
+    items: TTask['data'][];
+}
+interface HandleActionsInput extends HandleTasksInput {
+}
+export type UseActionsState<TTask> = [
+    TasksState<TTask>,
+    (input?: HandleActionsInput) => void
 ];
-export type UseHandlerState<T extends TaskData, R, U = undefined> = U extends undefined ? UseTaskState<T, R> : UseTasksState<T, R>;
-export type UseAction<V extends Record<keyof V, ActionHandler>> = <K extends keyof V, TData extends V[K] extends ActionHandler<infer D> ? D & TaskData : never, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(key: K, options?: U) => UseHandlerState<TData, V[K] extends ActionHandler<any, infer R> ? R : never, U>;
+interface HandleActionInput<TTask> extends HandleTaskInput<TTask> {
+}
+export type UseActionState<TTask extends Task> = [
+    {
+        task: TTask | undefined;
+        isProcessing: boolean;
+    },
+    (input: HandleActionInput<TTask['data']>) => void
+];
+/**
+ * @description `StorageBrowser` utility hook used to run default and custom action handlers from within a parent `StorageBrowser.Provider`. `useAction` provides the action handler with the current `location` state and credentials values, as well as any parameters provided as `data` at the `useAction` call site. accepts `handler` key to be run as initial argument and `options` with `items` as second. Returns batch tasks or atomic task state and `handler` accepting optional input allowing for location override
+ * @example
+ * batch actions - Returns batch task state and `handler` accepting optional input allowing for location override
+ * ```tsx
+ * // provide array of `items` to intialize `useAction` with batch handling behavior
+ * const items = [];
+ * const [{ tasks }, dispatchActions] = useAction('upload', { items })
+ *
+ * <button onClick={() => dispatchActions()}>start uploads</button>
+ * ```
+ *
+ * @example
+ * atomic action - returns atomic task `state` and `handler``input`, `handler` requires `input` containing `data` and `options`
+ * ```tsx
+ * // handler data
+ * const data = {}
+ * // do not provide `items` for atomic handling behavior
+ * const [{ task }, dispatchAction] = useAction('upload')
+ *
+ * <button onClick={() => dispatchAction({ data })}>start upload</button>
+ * ```
+ */
+export interface UseAction<Handlers extends Record<keyof Handlers, ActionHandler>> {
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options: UseActionOptionsWithItems<TTask>): UseActionsState<TTask>;
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options?: UseActionOptions<TTask>): UseActionState<TTask>;
+    <K extends keyof Handlers, TTask extends InferTask<Handlers[K]>>(key: K, options?: UseActionOptionsWithItems<TTask> | UseActionOptions<TTask>): UseActionsState<TTask> | UseActionState<TTask>;
+}
 export {};

package/dist/types/components/StorageBrowser/useAction/useHandler.d.ts

@@ -1,3 +1,4 @@
-import { TaskData, TaskHandler, TaskHandlerInput, TaskHandlerOutput } from '../actions';
-import { HandleTasksOptions, UseHandlerState } from './types';
-export declare const useHandler: <TData extends TaskData, RValue, TOptions extends HandleTasksOptions<TData>, U extends TOptions | undefined = undefined>(action: TaskHandler<TaskHandlerInput<TData, import("../actions").TaskHandlerOptions<any>>, TaskHandlerOutput<RValue>>, options?: U | undefined) => UseHandlerState<TData, RValue, U>;
+import { ActionHandler } from '../actions';
+import { InferTask, HandleTaskState, HandleTasksState, UseHandlerOptions, UseHandlerOptionsWithItems } from './types';
+export declare function useHandler<THandler extends ActionHandler, TTask extends InferTask<THandler>>(handler: THandler, options: UseHandlerOptionsWithItems<TTask>): HandleTasksState<TTask>;
+export declare function useHandler<THandler extends ActionHandler, TTask extends InferTask<THandler>>(handler: THandler, options?: UseHandlerOptions<TTask>): HandleTaskState<TTask>;

package/dist/types/components/StorageBrowser/useAction/useList.d.ts

@@ -1,9 +1,12 @@
-declare const LIST_ACTION_HOOKS: {
-    folderItems: () => import("./useListFolderItems").UseListFolderItemsState;
-    locationItems: () => import("./useListLocationItems").UseListLocationItemsState;
-    locations: () => import("./useListLocations").UseListLocationsState;
-};
-type ListActionHooks = typeof LIST_ACTION_HOOKS;
-export type UseList = <K extends keyof ListActionHooks, S extends ListActionHooks[K]>(type: K) => ReturnType<S>;
+import { UseListLocationsState } from './useListLocations';
+import { UseListLocationItemsState } from './useListLocationItems';
+import { UseListFolderItemsState } from './useListFolderItems';
+interface DefaultUseListStates {
+    folderItems: UseListFolderItemsState;
+    locationItems: UseListLocationItemsState;
+    locations: UseListLocationsState;
+}
+type UseListType = keyof DefaultUseListStates;
+export type UseList = <K extends UseListType>(type: K) => DefaultUseListStates[K];
 export declare const useList: UseList;
 export {};

package/dist/types/components/StorageBrowser/validators/assertRegisterAuthListener.d.ts

@@ -1,2 +1,2 @@
-import { RegisterAuthListener } from '../providers';
+import { RegisterAuthListener } from '../credentials';
 export declare function assertRegisterAuthListener(value: unknown): asserts value is RegisterAuthListener;