@aws-amplify/ui-react-core 1.0.5 → 2.1.0

package/dist/index.js

@@ -1,6 +1,638 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.useAuthenticator = exports.AuthenticatorProvider = void 0;
-var Authenticator_1 = require("./Authenticator");
-Object.defineProperty(exports, "AuthenticatorProvider", { enumerable: true, get: function () { return Authenticator_1.AuthenticatorProvider; } });
-Object.defineProperty(exports, "useAuthenticator", { enumerable: true, get: function () { return Authenticator_1.useAuthenticator; } });
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var jsxRuntime = require('react/jsx-runtime');
+var React = require('react');
+var react = require('@xstate/react');
+var ui = require('@aws-amplify/ui');
+var awsAmplify = require('aws-amplify');
+var isString = require('lodash/isString');
+var isEmpty = require('lodash/isEmpty');
+var isObject = require('lodash/isObject');
+var notifications = require('@aws-amplify/notifications');
+var core = require('@aws-amplify/core');
+var isNil = require('lodash/isNil');
+var isUndefined = require('lodash/isUndefined');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var isString__default = /*#__PURE__*/_interopDefaultLegacy(isString);
+var isEmpty__default = /*#__PURE__*/_interopDefaultLegacy(isEmpty);
+var isObject__default = /*#__PURE__*/_interopDefaultLegacy(isObject);
+var isNil__default = /*#__PURE__*/_interopDefaultLegacy(isNil);
+var isUndefined__default = /*#__PURE__*/_interopDefaultLegacy(isUndefined);
+
+/**
+ * AuthenticatorContext serves static reference to the auth machine service.
+ *
+ * https://xstate.js.org/docs/recipes/react.html#context-provider
+ */
+const AuthenticatorContext = React__default["default"].createContext(null);
+
+function AuthenticatorProvider({ children, }) {
+    /**
+     * Based on use cases, developer might already have added another Provider
+     * outside Authenticator. In that case, we sync the two providers by just
+     * passing the parent value.
+     *
+     * TODO(BREAKING): enforce only one provider in App tree
+     */
+    const parentProviderVal = React.useContext(AuthenticatorContext);
+    const service = react.useInterpret(ui.createAuthenticatorMachine);
+    const value = React.useMemo(() => (!parentProviderVal ? { service } : parentProviderVal), [parentProviderVal, service]);
+    const { service: activeService } = value;
+    React.useEffect(() => {
+        const unsubscribe = ui.listenToAuthHub(activeService);
+        return unsubscribe;
+    }, [activeService]);
+    return (jsxRuntime.jsx(AuthenticatorContext.Provider, Object.assign({ value: value }, { children: children })));
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+const USE_AUTHENTICATOR_ERROR = '`useAuthenticator` must be used inside an `Authenticator.Provider`.';
+
+function isEmptyArray(value) {
+    return Array.isArray(value) && isEmpty__default["default"](value);
+}
+function areEmptyArrays(...values) {
+    return values.every(isEmptyArray);
+}
+function isEmptyObject(value) {
+    return isObject__default["default"](value) && !Array.isArray(value) && isEmpty__default["default"](value);
+}
+function areEmptyObjects(...values) {
+    return values.every(isEmptyObject);
+}
+
+const COMPONENT_ROUTE_KEYS = [
+    'confirmResetPassword',
+    'confirmSignIn',
+    'confirmSignUp',
+    'confirmVerifyUser',
+    'forceNewPassword',
+    'resetPassword',
+    'setupTOTP',
+    'signIn',
+    'signUp',
+    'verifyUser',
+];
+const COMPONENT_ROUTE_NAMES = [
+    'ConfirmResetPassword',
+    'ConfirmSignIn',
+    'ConfirmSignUp',
+    'ConfirmVerifyUser',
+    'ForceNewPassword',
+    'ResetPassword',
+    'SetupTOTP',
+    'SignIn',
+    'SignUp',
+    'VerifyUser',
+];
+
+const isComponentRouteKey = (route) => COMPONENT_ROUTE_KEYS.some((componentRoute) => componentRoute === route);
+function resolveAuthenticatorComponents(defaults, overrides) {
+    if (!overrides) {
+        return defaults;
+    }
+    return COMPONENT_ROUTE_NAMES.reduce((components, route) => {
+        const Default = defaults[route];
+        const Override = overrides[route];
+        if (typeof Override !== 'function') {
+            return Object.assign(Object.assign({}, components), { [route]: Default });
+        }
+        const { Footer, FormFields, Header } = Default;
+        // cast to allow assigning of component slots
+        const Component = Override;
+        Component.Footer = Footer;
+        Component.FormFields = FormFields;
+        Component.Header = Header;
+        return Object.assign(Object.assign({}, components), { [route]: Component });
+    }, {});
+}
+
+const defaultComparator = () => false;
+/**
+ * Does an ordering and shallow comparison of each array value,
+ * plus a value equality check for empty objects and arrays.
+ */
+function areSelectorDepsEqual(currentDeps, nextDeps) {
+    if (currentDeps.length !== nextDeps.length) {
+        return false;
+    }
+    return currentDeps.every((currentDep, index) => {
+        const nextDep = nextDeps[index];
+        if (areEmptyArrays(currentDep, nextDep) ||
+            areEmptyObjects(currentDep, nextDep)) {
+            return true;
+        }
+        return currentDep === nextDep;
+    });
+}
+const getComparator = (selector) => (currentFacade, nextFacade) => {
+    const currentSelectorDeps = selector(currentFacade);
+    const nextSelectorDeps = selector(nextFacade);
+    // Shallow compare the array values
+    return areSelectorDepsEqual(currentSelectorDeps, nextSelectorDeps);
+};
+const getTotpSecretCodeCallback = (user) => function getTotpSecretCode() {
+    return __awaiter(this, void 0, void 0, function* () {
+        return yield awsAmplify.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 valueIsString = isString__default["default"](value);
+            if (!valueIsString || !name) {
+                return {};
+            }
+            return { name, label: value, type: 'radio', value };
+        }));
+};
+/**
+ * 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) => {
+    if (isComponentRouteKey(route)) {
+        return route === 'verifyUser'
+            ? convertContactMethodsToFields(unverifiedContactMethods)
+            : flattenFormFields(ui.getSortedFormFields(route, state));
+    }
+    return [];
+};
+
+/**
+ * [📖 Docs](https://ui.docs.amplify.aws/react/connected-components/authenticator/headless#useauthenticator-hook)
+ */
+function useAuthenticator(selector) {
+    const context = React__default["default"].useContext(AuthenticatorContext);
+    if (!context) {
+        throw new Error(USE_AUTHENTICATOR_ERROR);
+    }
+    const { service } = context;
+    const { send } = service;
+    const xstateSelector = React.useCallback((state) => (Object.assign({}, ui.getServiceFacade({ send, state }))), [send]);
+    const comparator = selector ? getComparator(selector) : defaultComparator;
+    const facade = react.useSelector(service, xstateSelector, comparator);
+    const { route, unverifiedContactMethods, user } = facade, rest = __rest(facade, ["route", "unverifiedContactMethods", "user"]);
+    // 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 `formFields` values required until form state is removed from state machine
+    const fields = React.useMemo(() => getMachineFields(route, serviceSnapshot, unverifiedContactMethods), [route, serviceSnapshot, unverifiedContactMethods]);
+    return Object.assign(Object.assign({}, rest), { getTotpSecretCode: getTotpSecretCodeCallback(user), route,
+        unverifiedContactMethods,
+        user,
+        /** @deprecated For internal use only */
+        fields });
+}
+
+/**
+ * Utility component for rendering nothing.
+ */
+function RenderNothing(_) {
+    return null;
+}
+
+const EVENT_HANDLER_KEY_MAP = {
+    updateBlur: 'handleBlur',
+    updateForm: 'handleChange',
+    submitForm: 'handleSubmit',
+};
+const COMMON_ROUTE_MACHINE_KEYS = [
+    'error',
+    'isPending',
+    'submitForm',
+    'updateBlur',
+    'updateForm',
+];
+const CONFIRM_RESET_PASSWORD_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'resendCode',
+    'validationErrors',
+];
+const CONFIRM_SIGN_IN_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toSignIn',
+    'user',
+];
+const CONFIRM_SIGN_UP_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'codeDeliveryDetails',
+    'resendCode',
+];
+const CONFIRM_VERIFY_USER_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'skipVerification',
+];
+const FORCE_NEW_PASSWORD_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toSignIn',
+    'validationErrors',
+];
+const RESET_PASSWORD_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toSignIn',
+];
+const SIGN_IN_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toFederatedSignIn',
+    'toResetPassword',
+    'toSignUp',
+];
+const SIGN_UP_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toSignIn',
+    'validationErrors',
+];
+const SETUP_TOTP_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'toSignIn',
+];
+const VERIFY_USER_MACHINE_KEYS = [
+    ...COMMON_ROUTE_MACHINE_KEYS,
+    'skipVerification',
+];
+const MACHINE_PROP_KEYS = {
+    confirmResetPassword: CONFIRM_RESET_PASSWORD_MACHINE_KEYS,
+    confirmSignIn: CONFIRM_SIGN_IN_MACHINE_KEYS,
+    confirmSignUp: CONFIRM_SIGN_UP_MACHINE_KEYS,
+    confirmVerifyUser: CONFIRM_VERIFY_USER_MACHINE_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,
+    verifyUser: VERIFY_USER_MACHINE_KEYS,
+};
+
+// only select `route` from machine context
+const routeSelector$1 = ({ route }) => [route];
+const createSelector = (selectorKeys) => (context) => {
+    const dependencies = selectorKeys.map((key) => context[key]);
+    // route should always be part of deps, so hook knows when route changes.
+    return [...dependencies, context.route];
+};
+const getRouteMachineSelector = (route) => isComponentRouteKey(route)
+    ? createSelector(MACHINE_PROP_KEYS[route])
+    : routeSelector$1;
+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] })), {});
+function resolveConfirmResetPasswordRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, 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 }) };
+}
+function resolveConfirmSignUpRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('confirmSignUp', props)),
+    };
+}
+function resolveConfirmVerifyUserRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('confirmVerifyUser', props)),
+    };
+}
+function resolveForceNewPasswordRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('forceNewPassword', props)),
+    };
+}
+function resolveResetPasswordRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('resetPassword', props)),
+    };
+}
+function resolveSetupTOTPRoute(Component, _a) {
+    var { getTotpSecretCode } = _a, props = __rest(_a, ["getTotpSecretCode"]);
+    return {
+        Component,
+        props: Object.assign(Object.assign(Object.assign({}, Component), getConvertedMachineProps('setupTOTP', props)), { getTotpSecretCode }),
+    };
+}
+function resolveSignInRoute(Component, props) {
+    // default `hideSignUp` to false
+    const hideSignUp = false;
+    return {
+        Component,
+        props: Object.assign(Object.assign(Object.assign({}, Component), getConvertedMachineProps('signIn', props)), { hideSignUp }),
+    };
+}
+function resolveSignUpRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('signUp', props)),
+    };
+}
+function resolveVerifyUserRoute(Component, props) {
+    return {
+        Component,
+        props: Object.assign(Object.assign({}, Component), getConvertedMachineProps('verifyUser', props)),
+    };
+}
+function resolveDefault() {
+    return {
+        Component: RenderNothing,
+        props: {},
+    };
+}
+
+function useAuthenticatorRoute({ components, }) {
+    const { route } = useAuthenticator(routeSelector$1);
+    const routeMachineSelector = React.useMemo(() => getRouteMachineSelector(route), [route]);
+    // `useAuthenticator` exposes both state machine (example: `toSignIn`) and non-state machine
+    // props (example: `getTotpSecretCode`). `routeSelector` specifies which state machine props
+    // should be returned for a specific route.
+    // 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;
+    switch (route) {
+        case 'confirmResetPassword': {
+            return resolveConfirmResetPasswordRoute(ConfirmResetPassword, routeSelectorProps);
+        }
+        case 'confirmSignIn': {
+            return resolveConfirmSignInRoute(ConfirmSignIn, routeSelectorProps);
+        }
+        case 'confirmSignUp': {
+            return resolveConfirmSignUpRoute(ConfirmSignUp, routeSelectorProps);
+        }
+        case 'confirmVerifyUser': {
+            return resolveConfirmVerifyUserRoute(ConfirmVerifyUser, routeSelectorProps);
+        }
+        case 'forceNewPassword': {
+            return resolveForceNewPasswordRoute(ForceNewPassword, routeSelectorProps);
+        }
+        case 'resetPassword': {
+            return resolveResetPasswordRoute(ResetPassword, routeSelectorProps);
+        }
+        case 'setupTOTP': {
+            return resolveSetupTOTPRoute(SetupTOTP, routeSelectorProps);
+        }
+        case 'signIn': {
+            return resolveSignInRoute(SignIn, routeSelectorProps);
+        }
+        case 'signUp': {
+            return resolveSignUpRoute(SignUp, routeSelectorProps);
+        }
+        case 'verifyUser': {
+            return resolveVerifyUserRoute(VerifyUser, routeSelectorProps);
+        }
+        default: {
+            return resolveDefault();
+        }
+    }
+}
+
+// only select `route` from machine context
+const routeSelector = ({ route }) => [route];
+function useAuthenticatorInitMachine(data) {
+    const { route, initializeMachine } = useAuthenticator(routeSelector);
+    const hasInitialized = React__default["default"].useRef(false);
+    React__default["default"].useEffect(() => {
+        if (!hasInitialized.current && route === 'setup') {
+            initializeMachine(data);
+            hasInitialized.current = true;
+        }
+    }, [initializeMachine, route, data]);
+}
+
+const InAppMessagingContext = React.createContext(null);
+
+const { InAppMessaging: InAppMessaging$1 } = notifications.Notifications;
+function InAppMessagingProvider({ children, }) {
+    const [message, setMessage] = React.useState(null);
+    React.useEffect(() => {
+        const listener = InAppMessaging$1.onMessageReceived((message) => {
+            setMessage(message);
+        });
+        return listener.remove;
+    }, []);
+    const clearMessage = React.useCallback(() => {
+        setMessage(null);
+    }, []);
+    const value = React.useMemo(() => ({
+        clearMessage,
+        displayMessage: setMessage,
+        message,
+    }), [clearMessage, message]);
+    return (jsxRuntime.jsx(InAppMessagingContext.Provider, Object.assign({ value: value }, { children: children })));
+}
+
+/**
+ * Utility hook used to access the InAppMessagingContext values
+ *
+ * @returns {InAppMessagingContextType} InAppMessaging context values
+ */
+function useInAppMessaging() {
+    const inAppMessagingContext = React.useContext(InAppMessagingContext);
+    if (!inAppMessagingContext) {
+        throw new Error('InAppMessagingContext is empty, did you forget the InAppMessagingProvider?');
+    }
+    return inAppMessagingContext;
+}
+
+const logger$2 = new core.ConsoleLogger('Notifications.InAppMessaging');
+const positions = {
+    BOTTOM_BANNER: 'bottom',
+    MIDDLE_BANNER: 'middle',
+    TOP_BANNER: 'top',
+};
+const getPositionProp = (layout) => positions[layout];
+const getActionHandler = (actionParams, onMessageAction, onActionCallback) => ({
+    onAction() {
+        try {
+            onMessageAction(actionParams);
+        }
+        catch (e) {
+            logger$2.error(`Message action failure: ${e}`);
+        }
+        finally {
+            onActionCallback();
+        }
+    },
+});
+const getButtonProps = (_a, onMessageAction, onActionCallback) => {
+    var { action, url } = _a, baseButtonProps = __rest(_a, ["action", "url"]);
+    return (Object.assign(Object.assign({}, baseButtonProps), getActionHandler({ action, url }, onMessageAction, onActionCallback)));
+};
+const getContentProps = (content, onMessageAction, onActionCallback) => {
+    const props = {};
+    if (!content) {
+        return props;
+    }
+    const { primaryButton, secondaryButton } = content, restContent = __rest(content, ["primaryButton", "secondaryButton"]);
+    if (primaryButton) {
+        props.primaryButton = getButtonProps(primaryButton, onMessageAction, onActionCallback);
+    }
+    if (secondaryButton) {
+        props.secondaryButton = getButtonProps(secondaryButton, onMessageAction, onActionCallback);
+    }
+    return Object.assign(Object.assign({}, props), restContent);
+};
+
+const EMPTY_PROPS = Object.freeze({});
+const logger$1 = new core.ConsoleLogger('Notifications.InAppMessaging');
+const { InAppMessaging } = notifications.Notifications;
+/**
+ * Utility hook for parsing a message and retrieving its corresponding UI component and props
+ *
+ * @param {UseMessageParams} props - platform specific UI components, action handler, and styles
+ * @returns {UseMessage} message UI component and props
+ */
+function useMessage({ components, onMessageAction, }) {
+    const { clearMessage, message } = useInAppMessaging();
+    const { BannerMessage, CarouselMessage, FullScreenMessage, ModalMessage } = components;
+    if (isNil__default["default"](message)) {
+        return {
+            Component: RenderNothing,
+            props: EMPTY_PROPS,
+        };
+    }
+    const { content, layout } = message;
+    const onActionCallback = () => {
+        InAppMessaging.notifyMessageInteraction(message, notifications.InAppMessageInteractionEvent.MESSAGE_ACTION_TAKEN);
+        clearMessage();
+    };
+    const onClose = () => {
+        InAppMessaging.notifyMessageInteraction(message, notifications.InAppMessageInteractionEvent.MESSAGE_DISMISSED);
+        clearMessage();
+    };
+    const onDisplay = () => {
+        InAppMessaging.notifyMessageInteraction(message, notifications.InAppMessageInteractionEvent.MESSAGE_DISPLAYED);
+    };
+    switch (layout) {
+        case 'BOTTOM_BANNER':
+        case 'MIDDLE_BANNER':
+        case 'TOP_BANNER': {
+            const props = Object.assign(Object.assign({}, getContentProps(content === null || content === void 0 ? void 0 : content[0], onMessageAction, onActionCallback)), { layout,
+                onClose,
+                onDisplay, position: getPositionProp(layout) });
+            return { Component: BannerMessage, props };
+        }
+        case 'CAROUSEL': {
+            const props = {
+                data: content === null || content === void 0 ? void 0 : content.map((item) => getContentProps(item, onMessageAction, onActionCallback)),
+                layout,
+                onClose,
+                onDisplay,
+            };
+            return { Component: CarouselMessage, props };
+        }
+        case 'FULL_SCREEN': {
+            const props = Object.assign(Object.assign({}, getContentProps(content === null || content === void 0 ? void 0 : content[0], onMessageAction, onActionCallback)), { layout,
+                onClose,
+                onDisplay });
+            return { Component: FullScreenMessage, props };
+        }
+        case 'MODAL': {
+            const props = Object.assign(Object.assign({}, getContentProps(content === null || content === void 0 ? void 0 : content[0], onMessageAction, onActionCallback)), { layout,
+                onClose,
+                onDisplay });
+            return { Component: ModalMessage, props };
+        }
+        default: {
+            logger$1.info(`Received unknown InAppMessage layout: ${layout}`);
+            return {
+                Component: RenderNothing,
+                props: EMPTY_PROPS,
+            };
+        }
+    }
+}
+
+const logger = new core.ConsoleLogger('Notifications.InAppMessaging');
+const handleMessageAction = ({ action, handleMessageLinkAction, url, }) => {
+    logger.info(`Handle action: ${action}`);
+    if (action === 'LINK' || action === 'DEEP_LINK') {
+        if (!isString__default["default"](url)) {
+            logger.warn(`url must be of type string: ${url}`);
+            return;
+        }
+        handleMessageLinkAction(url);
+    }
+};
+
+function usePreviousValue(value) {
+    const previous = React.useRef();
+    // update ref post render
+    React.useEffect(() => {
+        previous.current = value;
+    }, [value]);
+    // return previous ref
+    return previous.current;
+}
+
+function useHasValueUpdated(value, ignoreFirstRender = false) {
+    const previous = usePreviousValue(value);
+    const shouldIgnoreChange = isUndefined__default["default"](previous) && ignoreFirstRender;
+    if (shouldIgnoreChange) {
+        return false;
+    }
+    return previous !== value;
+}
+
+exports.AuthenticatorProvider = AuthenticatorProvider;
+exports.InAppMessagingProvider = InAppMessagingProvider;
+exports.handleMessageAction = handleMessageAction;
+exports.isAuthenticatorComponentRouteKey = isComponentRouteKey;
+exports.resolveAuthenticatorComponents = resolveAuthenticatorComponents;
+exports.useAuthenticator = useAuthenticator;
+exports.useAuthenticatorInitMachine = useAuthenticatorInitMachine;
+exports.useAuthenticatorRoute = useAuthenticatorRoute;
+exports.useHasValueUpdated = useHasValueUpdated;
+exports.useInAppMessaging = useInAppMessaging;
+exports.useMessage = useMessage;
+exports.usePreviousValue = usePreviousValue;

package/dist/types/Authenticator/hooks/__mock__/components.d.ts

@@ -0,0 +1,7 @@
+import { Defaults, Overrides } from '../types';
+declare type DefaultComponents<P> = Defaults<P>;
+export declare const DEFAULTS: DefaultComponents<{}>;
+export declare const OVERRIDES: Overrides;
+export declare const INVALID_SIGN_IN_OVERRIDES: Overrides;
+export declare const INVALID_OVERRIDES: Overrides<{}, {}>;
+export {};

package/dist/types/Authenticator/hooks/__tests__/utils.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/Authenticator/hooks/constants.d.ts

@@ -0,0 +1,3 @@
+import { AuthenticatorRouteComponentKey, AuthenticatorRouteComponentName } from './types';
+export declare const COMPONENT_ROUTE_KEYS: AuthenticatorRouteComponentKey[];
+export declare const COMPONENT_ROUTE_NAMES: AuthenticatorRouteComponentName[];

package/dist/types/Authenticator/hooks/index.d.ts

@@ -1 +1,5 @@
 export * from './useAuthenticator';
+export * from './useAuthenticatorRoute';
+export * from './useAuthenticatorInitMachine';
+export * from './utils';
+export * from './types';