@reactionable/amplify/lib/esm/identity/Identity.js

Reactionable package for Amplify

import { jsx as _jsx } from "react/jsx-runtime";
import { Authenticator } from "@aws-amplify/ui-react";
import { signIn, signOut, getCurrentUser, fetchAuthSession } from "aws-amplify/auth";
import { useTranslation, IdentityContextProvider as CoreIdentityContextProvider, useIdentityContext as coreUseIdentityContext, useIdentityProviderProps as coreUseIdentityProviderProps, } from "@reactionable/core";
import { useEffect, useState } from "react";
const dataToUser = (data) => {
    if (!data) {
        return null;
    }
    return {
        id: data.userId,
        username: data.username,
    };
};
function AuthComponent(props) {
    const { t } = useTranslation();
    const { setUser } = useIdentityContext();
    const authenticatorProps = Object.assign({
        errorMessage: (message) => t(message),
        ...props,
    });
    return (_jsx(Authenticator, { ...authenticatorProps, onStateChange: (authState, data) => {
            setUser(authState !== "signedIn" ? null : dataToUser(data));
        } }));
}
export const useIdentityProviderProps = (props = {}) => {
    const user = props.user;
    const [userState, setUser] = useState();
    useEffect(() => {
        if (user && user !== userState) {
            setUser(user);
            return;
        }
        if (userState === undefined) {
            fetchAuthSession()
                .then((data) => {
                if (!data.identityId) {
                    return;
                }
                getCurrentUser()
                    .then((data) => {
                    setUser(dataToUser(data));
                })
                    .catch((error) => {
                    if (error === "The user is not authenticated") {
                        setUser(null);
                    }
                    else {
                        throw error;
                    }
                });
            })
                .catch((error) => {
                if (error === "The user is not authenticated") {
                    setUser(null);
                }
                else {
                    throw error;
                }
            });
            return;
        }
    }, [user, userState]);
    return {
        ...coreUseIdentityProviderProps(),
        identityProvider: "Amplify",
        logout: async () => await signOut(),
        login: async (values) => {
            const result = await signIn(values);
            if (result.isSignedIn) {
                const user = dataToUser(await getCurrentUser());
                if (user) {
                    return user;
                }
            }
            throw new Error("No user retrieved from signIn");
        },
        AuthComponent,
        user,
        ...props,
    };
};
export function useIdentityContext() {
    return coreUseIdentityContext();
}
export function withIdentityContext(Component, identityProviderProps) {
    return (_jsx(IdentityContextProvider, { ...useIdentityProviderProps(identityProviderProps), children: _jsx(Component, {}) }));
}
export const IdentityContextProvider = (props) => {
    return _jsx(CoreIdentityContextProvider, { ...useIdentityProviderProps(props) });
};
//# sourceMappingURL=Identity.js.map