@aws-amplify/ui-react-core 2.1.33 → 3.0.1

package/dist/esm/Authenticator/context/AuthenticatorProvider.mjs

@@ -1,13 +1,12 @@
-import { __awaiter } from '../../node_modules/tslib/tslib.es6.mjs';
 import React__default, { useContext, useMemo, useEffect } from 'react';
 import { useInterpret } from '@xstate/react';
-import { Auth } from 'aws-amplify';
+import { getCurrentUser } from 'aws-amplify/auth';
 import { createAuthenticatorMachine, listenToAuthHub, defaultAuthHubHandler } from '@aws-amplify/ui';
 import { AuthenticatorContext } from './AuthenticatorContext.mjs';
 
-const createHubHandler = (options) => (data, service) => __awaiter(void 0, void 0, void 0, function* () {
-    yield defaultAuthHubHandler(data, service, options);
-});
+const createHubHandler = (options) => async (data, service) => {
+    await defaultAuthHubHandler(data, service, options);
+};
 function AuthenticatorProvider({ children, }) {
     // `authStatus` is exposed by `useAuthenticator` but should not be derived directly from the
     // state machine as the machine only updates on `Authenticator` initiated events, which
@@ -16,7 +15,7 @@ function AuthenticatorProvider({ children, }) {
     const [authStatus, setAuthStatus] = React__default.useState('configuring');
     // only run on first render
     React__default.useEffect(() => {
-        Auth.currentAuthenticatedUser()
+        getCurrentUser()
             .then(() => {
             setAuthStatus('authenticated');
         })

package/dist/esm/Authenticator/hooks/constants.mjs

@@ -4,8 +4,8 @@ const COMPONENT_ROUTE_KEYS = [
     'confirmSignUp',
     'confirmVerifyUser',
     'forceNewPassword',
-    'resetPassword',
-    'setupTOTP',
+    'forgotPassword',
+    'setupTotp',
     'signIn',
     'signUp',
     'verifyUser',
@@ -16,8 +16,8 @@ const COMPONENT_ROUTE_NAMES = [
     'ConfirmSignUp',
     'ConfirmVerifyUser',
     'ForceNewPassword',
-    'ResetPassword',
-    'SetupTOTP',
+    'ForgotPassword',
+    'SetupTotp',
     'SignIn',
     'SignUp',
     'VerifyUser',

package/dist/esm/Authenticator/hooks/useAuthenticator/useAuthenticator.mjs

@@ -1,11 +1,10 @@
-import { __rest } from '../../../node_modules/tslib/tslib.es6.mjs';
 import React__default, { useCallback } from 'react';
 import { useSelector } from '@xstate/react';
 import { getServiceFacade } from '@aws-amplify/ui';
-import 'aws-amplify';
+import 'aws-amplify/auth';
 import { AuthenticatorContext } from '../../context/AuthenticatorContext.mjs';
 import { USE_AUTHENTICATOR_ERROR } from './constants.mjs';
-import { getQRFields, getMachineFields, getTotpSecretCodeCallback, getComparator, defaultComparator } from './utils.mjs';
+import { getQRFields, getMachineFields, getComparator, defaultComparator } from './utils.mjs';
 
 /**
  * [📖 Docs](https://ui.docs.amplify.aws/react/connected-components/authenticator/headless#useauthenticator-hook)
@@ -17,27 +16,31 @@ function useAuthenticator(selector) {
     }
     const { service } = context;
     const { send } = service;
-    const xstateSelector = useCallback((state) => (Object.assign({}, getServiceFacade({ send, state }))), [send]);
+    const xstateSelector = useCallback((state) => ({ ...getServiceFacade({ send, state }) }), [send]);
     const comparator = selector ? getComparator(selector) : defaultComparator;
     // the purpose of `context.authStatus`is to intentionally override `facade.authStatus`. `facade.authStatus` does
     // not update on external sign in events (for example when a user is not using the `Authenticator`).
     const { authStatus } = context;
     const facade = useSelector(service, xstateSelector, comparator);
-    const { route, totpSecretCode, unverifiedContactMethods, user } = facade, rest = __rest(facade, ["route", "totpSecretCode", "unverifiedContactMethods", "user"]);
+    const { route, totpSecretCode, unverifiedUserAttributes, user, ...rest } = facade;
     // do not memoize output. `service.getSnapshot` reference remains stable preventing
     // `fields` from updating with current form state on value changes
     const serviceSnapshot = service.getSnapshot();
-    // legacy `QRFields` values only used for SetupTOTP page to retrieve issuer information, will be removed in future
-    const QRFields = route === 'setupTOTP' ? getQRFields(serviceSnapshot) : null;
+    // legacy `QRFields` values only used for SetupTotp page to retrieve issuer information, will be removed in future
+    const QRFields = route === 'setupTotp' ? getQRFields(serviceSnapshot) : null;
     // legacy `formFields` values required until form state is removed from state machine
-    const fields = getMachineFields(route, serviceSnapshot, unverifiedContactMethods);
-    return Object.assign(Object.assign({}, rest), { authStatus,
+    const fields = getMachineFields(route, serviceSnapshot, unverifiedUserAttributes);
+    return {
+        ...rest,
+        authStatus,
         route,
         totpSecretCode,
-        unverifiedContactMethods,
+        unverifiedUserAttributes,
         user,
         /** @deprecated For internal use only */
-        fields, getTotpSecretCode: getTotpSecretCodeCallback(user), QRFields });
+        fields,
+        QRFields,
+    };
 }
 
 export { useAuthenticator as default };

package/dist/esm/Authenticator/hooks/useAuthenticator/utils.mjs

@@ -1,5 +1,3 @@
-import { __awaiter } from '../../../node_modules/tslib/tslib.es6.mjs';
-import { Auth } from 'aws-amplify';
 import { getActorContext, getSortedFormFields, isString, areEmptyArrays, areEmptyObjects } from '@aws-amplify/ui';
 import { isComponentRouteKey } from '../utils.mjs';
 
@@ -27,19 +25,13 @@ const getComparator = (selector) => (currentFacade, nextFacade) => {
     // Shallow compare the array values
     return areSelectorDepsEqual(currentSelectorDeps, nextSelectorDeps);
 };
-const getQRFields = (state) => {
-    var _a, _b, _c;
-    return (Object.assign({}, (_c = (_b = (_a = getActorContext(state)) === null || _a === void 0 ? void 0 : _a.formFields) === null || _b === void 0 ? void 0 : _b.setupTOTP) === null || _c === void 0 ? void 0 : _c.QR));
-};
-const getTotpSecretCodeCallback = (user) => function getTotpSecretCode() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield Auth.setupTOTP(user);
-    });
-};
-const flattenFormFields = (fields) => fields.flatMap(([name, options]) => (Object.assign({ name }, options)));
-const convertContactMethodsToFields = (unverifiedContactMethods) => {
-    return (unverifiedContactMethods &&
-        Object.entries(unverifiedContactMethods).map(([name, value]) => {
+const getQRFields = (state) => ({
+    ...getActorContext(state)?.formFields?.setupTotp?.QR,
+});
+const flattenFormFields = (fields) => fields.flatMap(([name, options]) => ({ name, ...options }));
+const convertContactMethodsToFields = (unverifiedUserAttributes) => {
+    return (unverifiedUserAttributes &&
+        Object.entries(unverifiedUserAttributes).map(([name, value]) => {
             const valueIsString = isString(value);
             if (!valueIsString || !name) {
                 return {};
@@ -51,13 +43,13 @@ const convertContactMethodsToFields = (unverifiedContactMethods) => {
  * Retrieves default and custom (RWA only, to be updated) form field values from state machine
  * for subcomponent routes that render fields
  */
-const getMachineFields = (route, state, unverifiedContactMethods) => {
+const getMachineFields = (route, state, unverifiedUserAttributes) => {
     if (isComponentRouteKey(route)) {
         return route === 'verifyUser'
-            ? convertContactMethodsToFields(unverifiedContactMethods)
+            ? convertContactMethodsToFields(unverifiedUserAttributes)
             : flattenFormFields(getSortedFormFields(route, state));
     }
     return [];
 };
 
-export { areSelectorDepsEqual, defaultComparator, getComparator, getMachineFields, getQRFields, getTotpSecretCodeCallback };
+export { areSelectorDepsEqual, defaultComparator, getComparator, getMachineFields, getQRFields };

package/dist/esm/Authenticator/hooks/useAuthenticatorRoute/constants.mjs

@@ -18,8 +18,8 @@ const CONFIRM_RESET_PASSWORD_MACHINE_KEYS = [
 ];
 const CONFIRM_SIGN_IN_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
+    'challengeName',
     'toSignIn',
-    'user',
 ];
 const CONFIRM_SIGN_UP_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
@@ -42,13 +42,15 @@ const RESET_PASSWORD_MACHINE_KEYS = [
 ];
 const SIGN_IN_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
+    'socialProviders',
     'toFederatedSignIn',
-    'toResetPassword',
+    'toForgotPassword',
     'toSignUp',
 ];
 const SIGN_UP_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
     'hasValidationErrors',
+    'socialProviders',
     'toSignIn',
     'validationErrors',
 ];
@@ -56,6 +58,7 @@ const SETUP_TOTP_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
     'toSignIn',
     'totpSecretCode',
+    'username',
 ];
 const VERIFY_USER_MACHINE_KEYS = [
     ...COMMON_ROUTE_MACHINE_KEYS,
@@ -69,8 +72,8 @@ const MACHINE_PROP_KEYS = {
     forceNewPassword: FORCE_NEW_PASSWORD_MACHINE_KEYS,
     signIn: SIGN_IN_MACHINE_KEYS,
     signUp: SIGN_UP_MACHINE_KEYS,
-    resetPassword: RESET_PASSWORD_MACHINE_KEYS,
-    setupTOTP: SETUP_TOTP_MACHINE_KEYS,
+    forgotPassword: RESET_PASSWORD_MACHINE_KEYS,
+    setupTotp: SETUP_TOTP_MACHINE_KEYS,
     verifyUser: VERIFY_USER_MACHINE_KEYS,
 };
 

package/dist/esm/Authenticator/hooks/useAuthenticatorRoute/useAuthenticatorRoute.mjs

@@ -1,6 +1,6 @@
 import { useMemo } from 'react';
 import useAuthenticator from '../useAuthenticator/useAuthenticator.mjs';
-import { getRouteMachineSelector, resolveDefault, resolveVerifyUserRoute, resolveSignUpRoute, resolveSignInRoute, resolveSetupTOTPRoute, resolveResetPasswordRoute, resolveForceNewPasswordRoute, resolveConfirmVerifyUserRoute, resolveConfirmSignUpRoute, resolveConfirmSignInRoute, resolveConfirmResetPasswordRoute, routeSelector } from './utils.mjs';
+import { getRouteMachineSelector, resolveDefault, resolveVerifyUserRoute, resolveSignUpRoute, resolveSignInRoute, resolveSetupTotpRoute, resolveForgotPasswordRoute, resolveForceNewPasswordRoute, resolveConfirmVerifyUserRoute, resolveConfirmSignUpRoute, resolveConfirmSignInRoute, resolveConfirmResetPasswordRoute, routeSelector } from './utils.mjs';
 
 function useAuthenticatorRoute({ components, }) {
     const { route } = useAuthenticator(routeSelector);
@@ -11,7 +11,7 @@ function useAuthenticatorRoute({ components, }) {
     // Only state machine props specified by the current `routeSelector` will have their current value
     // returned by `useAuthenticator`, non-machine props returned will always be the current value
     const routeSelectorProps = useAuthenticator(routeMachineSelector);
-    const { ConfirmResetPassword, ConfirmSignIn, ConfirmSignUp, ConfirmVerifyUser, ForceNewPassword, ResetPassword, SetupTOTP, SignIn, SignUp, VerifyUser, } = components;
+    const { ConfirmResetPassword, ConfirmSignIn, ConfirmSignUp, ConfirmVerifyUser, ForceNewPassword, ForgotPassword, SetupTotp, SignIn, SignUp, VerifyUser, } = components;
     switch (route) {
         case 'confirmResetPassword': {
             return resolveConfirmResetPasswordRoute(ConfirmResetPassword, routeSelectorProps);
@@ -28,11 +28,11 @@ function useAuthenticatorRoute({ components, }) {
         case 'forceNewPassword': {
             return resolveForceNewPasswordRoute(ForceNewPassword, routeSelectorProps);
         }
-        case 'resetPassword': {
-            return resolveResetPasswordRoute(ResetPassword, routeSelectorProps);
+        case 'forgotPassword': {
+            return resolveForgotPasswordRoute(ForgotPassword, routeSelectorProps);
         }
-        case 'setupTOTP': {
-            return resolveSetupTOTPRoute(SetupTOTP, routeSelectorProps);
+        case 'setupTotp': {
+            return resolveSetupTotpRoute(SetupTotp, routeSelectorProps);
         }
         case 'signIn': {
             return resolveSignInRoute(SignIn, routeSelectorProps);

package/dist/esm/Authenticator/hooks/useAuthenticatorRoute/utils.mjs

@@ -1,4 +1,7 @@
-import { __rest } from '../../../node_modules/tslib/tslib.es6.mjs';
+import 'react';
+import 'react-hook-form';
+import '@aws-amplify/ui';
+import '../../../components/FormCore/FormProvider.mjs';
 import RenderNothing from '../../../components/RenderNothing/RenderNothing.mjs';
 import { isComponentRouteKey } from '../utils.mjs';
 import { MACHINE_PROP_KEYS, EVENT_HANDLER_KEY_MAP } from './constants.mjs';
@@ -15,47 +18,66 @@ const getRouteMachineSelector = (route) => isComponentRouteKey(route)
     : routeSelector;
 const isFormEventHandlerKey = (key) => ['updateBlur', 'updateForm', 'submitForm'].includes(key);
 const convertEventHandlerKey = (key) => EVENT_HANDLER_KEY_MAP[key];
-const getConvertedMachineProps = (route, context) => MACHINE_PROP_KEYS[route].reduce((acc, key) => (Object.assign(Object.assign({}, acc), { [isFormEventHandlerKey(key) ? convertEventHandlerKey(key) : key]: context[key] })), {});
+const getConvertedMachineProps = (route, context) => MACHINE_PROP_KEYS[route].reduce((acc, key) => ({
+    ...acc,
+    [isFormEventHandlerKey(key) ? convertEventHandlerKey(key) : key]: context[key],
+}), {});
 function resolveConfirmResetPasswordRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('confirmResetPassword', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('confirmResetPassword', props),
+        },
     };
 }
 function resolveConfirmSignInRoute(Component, props) {
-    const _a = getConvertedMachineProps('confirmSignIn', props), { user } = _a, machineProps = __rest(_a, ["user"]);
-    // prior to the `confirmSignIn` route, `user.username` is populated
-    const challengeName = user.challengeName;
-    return { Component, props: Object.assign(Object.assign(Object.assign({}, Component), machineProps), { challengeName }) };
+    const { challengeName, ...machineProps } = getConvertedMachineProps('confirmSignIn', props);
+    return { Component, props: { ...Component, ...machineProps, challengeName } };
 }
 function resolveConfirmSignUpRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('confirmSignUp', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('confirmSignUp', props),
+        },
     };
 }
 function resolveConfirmVerifyUserRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('confirmVerifyUser', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('confirmVerifyUser', props),
+        },
     };
 }
 function resolveForceNewPasswordRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('forceNewPassword', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('forceNewPassword', props),
+        },
     };
 }
-function resolveResetPasswordRoute(Component, props) {
+function resolveForgotPasswordRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('resetPassword', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('forgotPassword', props),
+        },
     };
 }
-function resolveSetupTOTPRoute(Component, props) {
+function resolveSetupTotpRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('setupTOTP', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('setupTotp', props),
+        },
     };
 }
 function resolveSignInRoute(Component, props) {
@@ -63,19 +85,26 @@ function resolveSignInRoute(Component, props) {
     const hideSignUp = false;
     return {
         Component,
-        props: Object.assign(Object.assign(Object.assign({}, Component), getConvertedMachineProps('signIn', props)), { hideSignUp }),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('signIn', props),
+            hideSignUp,
+        },
     };
 }
 function resolveSignUpRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('signUp', props)),
+        props: { ...Component, ...getConvertedMachineProps('signUp', props) },
     };
 }
 function resolveVerifyUserRoute(Component, props) {
     return {
         Component,
-        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('verifyUser', props)),
+        props: {
+            ...Component,
+            ...getConvertedMachineProps('verifyUser', props),
+        },
     };
 }
 function resolveDefault() {
@@ -85,4 +114,4 @@ function resolveDefault() {
     };
 }
 
-export { getRouteMachineSelector, resolveConfirmResetPasswordRoute, resolveConfirmSignInRoute, resolveConfirmSignUpRoute, resolveConfirmVerifyUserRoute, resolveDefault, resolveForceNewPasswordRoute, resolveResetPasswordRoute, resolveSetupTOTPRoute, resolveSignInRoute, resolveSignUpRoute, resolveVerifyUserRoute, routeSelector };
+export { getRouteMachineSelector, resolveConfirmResetPasswordRoute, resolveConfirmSignInRoute, resolveConfirmSignUpRoute, resolveConfirmVerifyUserRoute, resolveDefault, resolveForceNewPasswordRoute, resolveForgotPasswordRoute, resolveSetupTotpRoute, resolveSignInRoute, resolveSignUpRoute, resolveVerifyUserRoute, routeSelector };

package/dist/esm/Authenticator/hooks/utils.mjs

@@ -9,7 +9,7 @@ function resolveAuthenticatorComponents(defaults, overrides) {
         const Default = defaults[route];
         const Override = overrides[route];
         if (typeof Override !== 'function') {
-            return Object.assign(Object.assign({}, components), { [route]: Default });
+            return { ...components, [route]: Default };
         }
         const { Footer, FormFields, Header } = Default;
         // cast to allow assigning of component slots
@@ -17,7 +17,7 @@ function resolveAuthenticatorComponents(defaults, overrides) {
         Component.Footer = Footer;
         Component.FormFields = FormFields;
         Component.Header = Header;
-        return Object.assign(Object.assign({}, components), { [route]: Component });
+        return { ...components, [route]: Component };
     }, {});
 }
 

package/dist/esm/components/FormCore/FormProvider.mjs

@@ -0,0 +1,15 @@
+import React__default from 'react';
+import { useForm, FormProvider as FormProvider$1 } from 'react-hook-form';
+
+const DEFAULT_MODE = 'onTouched';
+const FormProvider = React__default.forwardRef(function FormProvider({ children, defaultValues, mode = DEFAULT_MODE }, ref) {
+    const formProviderProps = useForm({
+        defaultValues,
+        mode,
+    });
+    const { getValues, reset } = formProviderProps;
+    React__default.useImperativeHandle(ref, () => ({ getValues, reset: () => reset(defaultValues) }), [defaultValues, getValues, reset]);
+    return (React__default.createElement(FormProvider$1, { ...formProviderProps }, children));
+});
+
+export { FormProvider as default };

package/dist/esm/components/FormCore/useField.mjs

@@ -0,0 +1,20 @@
+import useForm from './useForm.mjs';
+
+const DEFAULT_ERROR_MESSAGE = '`useField` must be used within a `FormProvider`';
+/**
+ * `Field` integration hook for usage with React `Field` components.
+ *
+ * @param params Requires `name`, all additional params optional
+ * @returns `Form` aware `Field` event handlers and state values
+ */
+function useField(params) {
+    const { getFieldState, registerField } = useForm({
+        errorMessage: DEFAULT_ERROR_MESSAGE,
+    });
+    return {
+        ...registerField(params),
+        ...getFieldState(params.name),
+    };
+}
+
+export { DEFAULT_ERROR_MESSAGE, useField as default };

package/dist/esm/components/FormCore/useForm.mjs

@@ -0,0 +1,51 @@
+import React__default from 'react';
+import { useFormContext } from 'react-hook-form';
+import { noop } from '@aws-amplify/ui';
+
+const DEFAULT_ERROR_MESSAGE = '`useForm` must be called inside a `FormProvider`';
+/**
+ * Utility hook corresponding to `FormProvider`, must be used within a `FormProvider`
+ *
+ * @internal Extend for public export. `useForm` and `UseForm` are an abstraction layer
+ * on top of `useFormContext` and `UseFormReturn`, imported from `react-hook-form`
+ *
+ * @param options optional parameters
+ * @returns `Form` utilities
+ */
+function useForm(options = {}) {
+    const formContext = useFormContext();
+    const { errorMessage, onSubmit: _onSubmit } = options;
+    if (!formContext) {
+        throw new Error(errorMessage ?? DEFAULT_ERROR_MESSAGE);
+    }
+    const { formState, getFieldState: _getFieldState, getValues, handleSubmit, register, reset, setValue, } = formContext;
+    // Do not memoize, `formState` updates on all events
+    const getFieldState = (name) => {
+        const { error, ...fieldState } = _getFieldState(name, formState);
+        const { message: errorMessage } = error ?? {};
+        return { ...fieldState, errorMessage, hasError: !!errorMessage };
+    };
+    // memoize `registerField` and `setFormValue` together,
+    // `register` and `setValue` maintain stable references
+    const { registerField, setFormValue } = React__default.useMemo(() => {
+        return {
+            registerField: ({ name, ...options }) => register(name, options),
+            setFormValue: ({ name, value, ...options }) => setValue(name, value, options),
+        };
+    }, [register, setValue]);
+    const onSubmit = React__default.useCallback((event) => {
+        const handler = _onSubmit ? handleSubmit(_onSubmit) : noop;
+        handler(event);
+    }, [_onSubmit, handleSubmit]);
+    return {
+        getFieldState,
+        getValues,
+        isValid: formState.isValid,
+        onSubmit,
+        registerField,
+        reset,
+        setFormValue,
+    };
+}
+
+export { DEFAULT_ERROR_MESSAGE, useForm as default };

package/dist/esm/components/FormCore/withFormProvider.mjs

@@ -0,0 +1,15 @@
+import React__default from 'react';
+import FormProvider from './FormProvider.mjs';
+
+/**
+ * @param Child `Form` base component wrapped inside `FormProvider`
+ * @returns Composed `Form` component exposing `FormContext` values to descendents
+ */
+function withFormProvider(Child) {
+    return React__default.forwardRef(function Form({ defaultValues, mode, ...props }, ref) {
+        return (React__default.createElement(FormProvider, { defaultValues: defaultValues, mode: mode, ref: ref },
+            React__default.createElement(Child, { ...props })));
+    });
+}
+
+export { withFormProvider as default };

package/dist/esm/hooks/useSetUserAgent.mjs

@@ -0,0 +1,15 @@
+import { useEffect } from 'react';
+import { setUserAgent } from '@aws-amplify/ui';
+
+function useSetUserAgent({ componentName, packageName, version, }) {
+    useEffect(() => {
+        const clearUserAgent = setUserAgent({
+            componentName,
+            packageName,
+            version,
+        });
+        return clearUserAgent;
+    }, [componentName, packageName, version]);
+}
+
+export { useSetUserAgent as default };

package/dist/esm/hooks/useTimeout.mjs

@@ -0,0 +1,22 @@
+import React__default from 'react';
+import { isTypedFunction } from '@aws-amplify/ui';
+
+function useTimeout({ callback, delay, }) {
+    const storedCallback = React__default.useRef(callback);
+    React__default.useLayoutEffect(() => {
+        storedCallback.current = callback;
+    }, [callback]);
+    React__default.useEffect(() => {
+        if (!isTypedFunction(storedCallback.current) || !delay) {
+            return;
+        }
+        const timeoutId = setTimeout(() => {
+            storedCallback.current?.();
+        }, delay);
+        return () => {
+            clearTimeout(timeoutId);
+        };
+    }, [delay]);
+}
+
+export { useTimeout as default };

package/dist/esm/index.mjs

@@ -4,7 +4,14 @@ export { default as useAuthenticator } from './Authenticator/hooks/useAuthentica
 export { default as useAuthenticatorRoute } from './Authenticator/hooks/useAuthenticatorRoute/useAuthenticatorRoute.mjs';
 export { default as useAuthenticatorInitMachine } from './Authenticator/hooks/useAuthenticatorInitMachine/useAuthenticatorInitMachine.mjs';
 export { isComponentRouteKey as isAuthenticatorComponentRouteKey, resolveAuthenticatorComponents } from './Authenticator/hooks/utils.mjs';
+export { default as useField } from './components/FormCore/useField.mjs';
+export { default as useForm } from './components/FormCore/useForm.mjs';
+export { default as FormProvider } from './components/FormCore/FormProvider.mjs';
+export { default as withFormProvider } from './components/FormCore/withFormProvider.mjs';
 export { default as RenderNothing } from './components/RenderNothing/RenderNothing.mjs';
 export { default as useDeprecationWarning } from './hooks/useDeprecationWarning.mjs';
 export { default as useHasValueUpdated } from './hooks/useHasValueUpdated.mjs';
 export { default as usePreviousValue } from './hooks/usePreviousValue.mjs';
+export { default as useSetUserAgent } from './hooks/useSetUserAgent.mjs';
+export { default as useTimeout } from './hooks/useTimeout.mjs';
+export { default as createContextUtilities } from './utils/createContextUtilities.mjs';

package/dist/esm/utils/createContextUtilities.mjs

@@ -0,0 +1,80 @@
+import React__default from 'react';
+import { isUndefined, isString } from '@aws-amplify/ui';
+
+const INVALID_OPTIONS_MESSAGE = 'an `errorMessage` or a `defaultValue` must be provided in `options`';
+/**
+ * Uses `ContextType`/`Name` generics and `options` to create:
+ * - `${Name}Context`: React Context of type `ContextType`
+ * - `Provider${Name}`: React Context `Provider` component exposing the `ContextType`
+ *   as optional props
+ * - `use${Name}`: Utility Hook exposing the values of `ContextType`. Allows
+ *   params with `errorMessage` for granular error messaging
+ *
+ * @template ContextType Type definition of the Context.
+ * > For most use cases the keys of `ContextType` should not be optional in
+ * preference of explicit `undefined` to avoid optional types on the
+ * Utility Hook return
+ *
+ * @param options Context utility options. Requires a `contextName`, and
+ * either a `defaultValue` of `ContextType` **or** an `errorMessage`
+ * allowing for differing behaviors of the Utility Hook when used outside a
+ * parent `Provider`:
+ *
+ * - `defaultValue`: Ensures the Utility Hook returns a default value for
+ *   scenarios **where the missing context values should not impact usage**
+ * - `errorMessage`: Ensures the Utility Hook throws an error for
+ *   scenarios **where the missing context values should prevent** usage
+ *
+ * @returns `Context`, `Provider` Component and `useContext` Utility Hook
+ *
+ * @usage
+ * ```ts
+ * interface StuffContextType {
+ *   things: number;
+ * }
+ *
+ * // with `defaultValue`
+ * const defaultValue: StuffContextType = { things: 7 };
+ *
+ * const { StuffProvider, useStuff } = createContextUtilities({
+ *   contextName: 'Stuff',
+ *   defaultValue,
+ * });
+ *
+ * // with `errorMessage`
+ * const { StuffProvider, useStuff } = createContextUtilities<StuffContextType>({
+ *   contextName: 'Stuff',
+ *   errorMessage: '`useStuff` must be used in a `StuffProvider`'
+ * });
+ * ```
+ */
+function createContextUtilities(options) {
+    const { contextName, defaultValue, errorMessage } = options ?? {};
+    if (isUndefined(defaultValue) && !isString(errorMessage)) {
+        throw new Error(INVALID_OPTIONS_MESSAGE);
+    }
+    const Context = React__default.createContext(defaultValue);
+    function Provider(props) {
+        const { children, ...context } = props;
+        const value = React__default.useMemo(() => context, 
+        // Unpack `context` for the dep array; using `[context]` results in
+        // evaluation on every render
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+        Object.values(context));
+        return React__default.createElement(Context.Provider, { value: value }, children);
+    }
+    Provider.displayName = `${contextName}Provider`;
+    return {
+        [`use${contextName}`]: function (params) {
+            const context = React__default.useContext(Context);
+            if (isUndefined(context)) {
+                throw new Error(params?.errorMessage ?? errorMessage);
+            }
+            return context;
+        },
+        [`${contextName}Provider`]: Provider,
+        [`${contextName}Context`]: Context,
+    };
+}
+
+export { INVALID_OPTIONS_MESSAGE, createContextUtilities as default };