@gahojin-inc/amplify-auth-hooks 2025.8.0

package/dist/machines-CRIehDHl.js

@@ -0,0 +1,1372 @@
+import { assign, forwardTo, fromPromise, sendParent, setup } from "xstate";
+import { autoSignIn, confirmResetPassword, confirmSignIn, confirmSignUp, confirmUserAttribute, fetchUserAttributes, getCurrentUser, resendSignUpCode, resetPassword, sendUserAttributeVerificationCode, signIn, signInWithRedirect, signOut, signUp } from "@aws-amplify/auth";
+
+//#region src/machines/actions.ts
+const setTotpSecretCode = ({ event }) => {
+	const { sharedSecret } = event.output?.nextStep?.totpSetupDetails ?? {};
+	return sharedSecret;
+};
+const setAllowedMfaTypes = ({ event }) => {
+	return event.output?.nextStep?.allowedMFATypes;
+};
+const setShouldVerifyUserAttributeStep = "SHOULD_CONFIRM_USER_ATTRIBUTE";
+const setConfirmAttributeCompleteStep = "CONFIRM_ATTRIBUTE_COMPLETE";
+const setConfirmSignUpStep = "CONFIRM_SIGN_UP";
+const setNextSignInStep = ({ event }) => {
+	const output = event.output ?? {};
+	return output.nextStep?.signInStep === "DONE" ? "SIGN_IN_COMPLETE" : output.nextStep?.signInStep;
+};
+const setNextSignUpStep = ({ event }) => {
+	const output = event.output ?? {};
+	return output.nextStep?.signUpStep === "DONE" ? "SIGN_UP_COMPLETE" : output.nextStep?.signUpStep;
+};
+const setNextResetPasswordStep = ({ event }) => {
+	const output = event.output ?? {};
+	return output.nextStep?.resetPasswordStep === "DONE" ? "RESET_PASSWORD_COMPLETE" : output.nextStep?.resetPasswordStep;
+};
+const setRemoteError = ({ event }) => {
+	const error = event.error;
+	if (error?.name === "NoUserPoolError") return "Configuration error (see console) – please contact the administrator";
+	return error?.message || String(error);
+};
+const setUsername = ({ event }) => event.data?.username;
+const setCodeDeliveryDetails = ({ event }) => {
+	const output = event.output;
+	if (output?.nextStep?.codeDeliveryDetails) return output?.nextStep?.codeDeliveryDetails;
+	return output;
+};
+const setUnverifiedUserAttributes = ({ event }) => {
+	const { email, phone_number } = event.output;
+	const unverifiedUserAttributes = {
+		...email && { email },
+		...phone_number && { phone_number }
+	};
+	return unverifiedUserAttributes;
+};
+const setSelectedUserAttribute = ({ event }) => {
+	const output = event?.output;
+	return output?.attributeName;
+};
+
+//#endregion
+//#region src/machines/guards.ts
+const SIGN_IN_STEP_MFA_CONFIRMATION = [
+	"CONFIRM_SIGN_IN_WITH_SMS_CODE",
+	"CONFIRM_SIGN_IN_WITH_TOTP_CODE",
+	"CONFIRM_SIGN_IN_WITH_EMAIL_CODE"
+];
+const shouldConfirmSignInWithNewPassword = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signInStep === "CONFIRM_SIGN_IN_WITH_NEW_PASSWORD_REQUIRED";
+};
+const shouldResetPasswordFromSignIn = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signInStep === "RESET_PASSWORD";
+};
+const shouldConfirmSignUpFromSignIn = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signInStep === "CONFIRM_SIGN_UP";
+};
+const shouldAutoSignIn = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signUpStep === "COMPLETE_AUTO_SIGN_IN";
+};
+const hasCompletedSignIn = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signInStep === "DONE";
+};
+const hasCompletedSignUp = (event) => {
+	const output = event.output;
+	return output?.nextStep?.signUpStep === "DONE";
+};
+const hasCompletedResetPassword = (event) => {
+	const output = event.output;
+	return output?.nextStep?.resetPasswordStep === "DONE";
+};
+const hasCompletedAttributeConfirmation = (step) => {
+	return step === "CONFIRM_ATTRIBUTE_COMPLETE";
+};
+const isConfirmUserAttributeStep = (step) => {
+	return step === "CONFIRM_ATTRIBUTE_WITH_CODE";
+};
+const isShouldConfirmUserAttributeStep = (step) => {
+	return step === "SHOULD_CONFIRM_USER_ATTRIBUTE";
+};
+const isResetPasswordStep = (step) => {
+	return step === "RESET_PASSWORD";
+};
+const isConfirmSignUpStep = (step) => {
+	return step === "CONFIRM_SIGN_UP";
+};
+const isShouldConfirmSignInWithNewPassword = (step) => {
+	return step === "CONFIRM_SIGN_IN_WITH_NEW_PASSWORD_REQUIRED";
+};
+const shouldConfirmSignIn = (step) => {
+	return SIGN_IN_STEP_MFA_CONFIRMATION.includes(step);
+};
+const shouldSetupTotp = (step) => {
+	return step === "CONTINUE_SIGN_IN_WITH_TOTP_SETUP";
+};
+const shouldSetupEmail = (step) => {
+	return step === "CONTINUE_SIGN_IN_WITH_EMAIL_SETUP";
+};
+const shouldSelectMfaType = (step) => {
+	return ["CONTINUE_SIGN_IN_WITH_MFA_SELECTION", "CONTINUE_SIGN_IN_WITH_MFA_SETUP_SELECTION"].includes(step);
+};
+const shouldResetPassword = (context, event) => {
+	const step = event?.input?.step ?? context.step;
+	return step === "RESET_PASSWORD";
+};
+const shouldConfirmResetPassword = (context, event) => {
+	const step = event?.input?.step ?? context.step;
+	return step === "CONFIRM_RESET_PASSWORD_WITH_CODE";
+};
+const shouldVerifyAttribute = (event) => {
+	const { email, phone_number, phone_number_verified, email_verified } = event.output ?? {};
+	if (!email && !phone_number) return false;
+	const emailVerified = email_verified === "true";
+	const phoneVerified = phone_number_verified === "true";
+	return !emailVerified && !phoneVerified;
+};
+const isUserAlreadyConfirmed = (event) => {
+	return event.error?.message === "User is already confirmed.";
+};
+
+//#endregion
+//#region src/machines/signIn/actor.ts
+/**
+* @internal
+*/
+const signInActor = (handlers, overridesContext) => {
+	return setup({
+		types: {
+			context: {},
+			events: {}
+		},
+		guards: {
+			shouldConfirmSignIn: ({ context: { step } }) => shouldConfirmSignIn(step),
+			shouldSetupTotp: ({ context: { step } }) => shouldSetupTotp(step),
+			shouldSetupEmail: ({ context: { step } }) => shouldSetupEmail(step),
+			shouldSelectMfaType: ({ context: { step } }) => shouldSelectMfaType(step),
+			shouldVerifyAttribute: ({ event }) => shouldVerifyAttribute(event),
+			shouldConfirmSignInWithNewPassword: ({ event }) => shouldConfirmSignInWithNewPassword(event),
+			shouldResetPasswordFromSignIn: ({ event }) => shouldResetPasswordFromSignIn(event),
+			shouldConfirmSignUpFromSignIn: ({ event }) => shouldConfirmSignUpFromSignIn(event),
+			hasCompletedSignIn: ({ event }) => hasCompletedSignIn(event),
+			isShouldConfirmSignInWithNewPassword: ({ context: { step } }) => isShouldConfirmSignInWithNewPassword(step)
+		},
+		actors: {
+			fetchUserAttributes: fromPromise(() => handlers.fetchUserAttributes()),
+			resetPassword: fromPromise(({ input }) => handlers.resetPassword(input)),
+			resendSignUpCode: fromPromise(({ input }) => handlers.resendSignUpCode(input)),
+			signIn: fromPromise(({ input }) => handlers.signIn(input)),
+			confirmSignIn: fromPromise(({ input }) => handlers.confirmSignIn(input)),
+			signInWithRedirect: fromPromise(({ input }) => handlers.signInWithRedirect(input))
+		},
+		actions: {
+			sendUpdate: sendParent({ type: "CHILD_CHANGED" }),
+			setShouldVerifyUserAttributeStep: assign({ step: setShouldVerifyUserAttributeStep }),
+			setUnverifiedUserAttributes: assign({ unverifiedUserAttributes: setUnverifiedUserAttributes }),
+			setCodeDeliveryDetails: assign({ codeDeliveryDetails: setCodeDeliveryDetails }),
+			setConfirmAttributeCompleteStep: assign({ step: "CONFIRM_ATTRIBUTE_COMPLETE" }),
+			setTotpSecretCode: assign({ totpSecretCode: setTotpSecretCode }),
+			setAllowedMfaTypes: assign({ allowedMfaTypes: setAllowedMfaTypes }),
+			setNextSignInStep: assign({ step: setNextSignInStep }),
+			setConfirmSignUpStep: assign({ step: setConfirmSignUpStep }),
+			setActorDoneData: assign(({ event }) => {
+				const output = event?.output ?? {};
+				return {
+					codeDeliveryDetails: output.codeDeliveryDetails,
+					missingAttributes: output.missingAttributes,
+					remoteError: output.remoteError,
+					username: output.username,
+					step: output.step,
+					totpSecretCode: output.totpSecretCode,
+					unverifiedUserAttributes: output.unverifiedUserAttributes,
+					allowedMfaTypes: output.allowedMfaTypes
+				};
+			}),
+			setUsername: assign({ username: setUsername }),
+			setRemoteError: assign({ remoteError: setRemoteError }),
+			clearError: assign({ remoteError: void 0 })
+		}
+	}).createMachine({
+		id: "signInActor",
+		context: ({ input }) => ({
+			step: "SIGN_IN",
+			...overridesContext,
+			...input
+		}),
+		initial: "init",
+		states: {
+			init: { always: [
+				{
+					guard: "shouldConfirmSignIn",
+					target: "#signInActor.confirmSignIn"
+				},
+				{
+					guard: "shouldSetupTotp",
+					target: "#signInActor.setupTotp"
+				},
+				{
+					guard: "shouldSetupEmail",
+					target: "#signInActor.setupEmail"
+				},
+				{
+					guard: "shouldSelectMfaType",
+					target: "#signInActor.selectMfaType"
+				},
+				{
+					guard: "isShouldConfirmSignInWithNewPassword",
+					actions: "setActorDoneData",
+					target: "#signInActor.forceChangePassword"
+				},
+				{ target: "#signInActor.signIn" }
+			] },
+			federatedSignIn: {
+				entry: ["sendUpdate", "clearError"],
+				invoke: {
+					src: "signInWithRedirect",
+					input: ({ event }) => event.data,
+					onDone: { target: "#signInActor.signIn" },
+					onError: {
+						actions: "setRemoteError",
+						target: "#signInActor.signIn"
+					}
+				}
+			},
+			fetchUserAttributes: { invoke: {
+				src: "fetchUserAttributes",
+				onDone: [{
+					guard: "shouldVerifyAttribute",
+					actions: ["setShouldVerifyUserAttributeStep", "setUnverifiedUserAttributes"],
+					target: "#signInActor.resolved"
+				}, {
+					actions: "setConfirmAttributeCompleteStep",
+					target: "#signInActor.resolved"
+				}],
+				onError: {
+					actions: "setConfirmAttributeCompleteStep",
+					target: "#signInActor.resolved"
+				}
+			} },
+			resendSignUpCode: {
+				tags: "pending",
+				invoke: {
+					src: "resendSignUpCode",
+					input: ({ context: { username }, event }) => ({
+						username,
+						...event.data
+					}),
+					onDone: {
+						actions: "setCodeDeliveryDetails",
+						target: "#signInActor.resolved"
+					},
+					onError: {
+						actions: "setRemoteError",
+						target: "#signInActor.signIn"
+					}
+				}
+			},
+			resetPassword: { invoke: {
+				src: "resetPassword",
+				input: ({ context: { username }, event }) => ({
+					username,
+					...event.data
+				}),
+				onDone: {
+					actions: "setCodeDeliveryDetails",
+					target: "#signInActor.resolved"
+				},
+				onError: { actions: ["setRemoteError", "sendUpdate"] }
+			} },
+			signIn: {
+				initial: "idle",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							FEDERATED_SIGN_IN: { target: "#signInActor.federatedSignIn" },
+							SUBMIT: { target: "submit" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: [
+							"sendUpdate",
+							"setUsername",
+							"clearError"
+						],
+						invoke: {
+							src: "signIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: [{
+								guard: "shouldConfirmSignUpFromSignIn",
+								actions: "setConfirmSignUpStep",
+								target: "#signInActor.resendSignUpCode"
+							}, {
+								actions: "setRemoteError",
+								target: "idle"
+							}]
+						}
+					}
+				}
+			},
+			confirmSignIn: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							SIGN_IN: { target: "#signInActor.signIn" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			forceChangePassword: {
+				initial: "idle",
+				entry: "clearError",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: { SUBMIT: { target: "submit" } }
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			setupTotp: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							SIGN_IN: { target: "#signInActor.signIn" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			setupEmail: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							SIGN_IN: { target: "#signInActor.signIn" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			selectMfaType: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							SIGN_IN: { target: "#signInActor.signIn" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignIn",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.fetchUserAttributes"
+								},
+								{
+									guard: "shouldConfirmSignInWithNewPassword",
+									actions: "setNextSignInStep",
+									target: "#signInActor.forceChangePassword"
+								},
+								{
+									guard: "shouldResetPasswordFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resetPassword"
+								},
+								{
+									guard: "shouldConfirmSignUpFromSignIn",
+									actions: "setNextSignInStep",
+									target: "#signInActor.resendSignUpCode"
+								},
+								{
+									actions: [
+										"setNextSignInStep",
+										"setTotpSecretCode",
+										"setAllowedMfaTypes"
+									],
+									target: "#signInActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			resolved: { type: "final" }
+		},
+		output: ({ context }) => context
+	});
+};
+
+//#endregion
+//#region src/machines/defaultHandlers.ts
+const defaultHandlers = {
+	getCurrentUser,
+	fetchUserAttributes,
+	signIn,
+	signInWithRedirect,
+	signUp,
+	signOut,
+	autoSignIn,
+	confirmSignIn,
+	confirmSignUp,
+	confirmResetPassword,
+	confirmUserAttribute,
+	resetPassword,
+	resendSignUpCode,
+	sendUserAttributeVerificationCode
+};
+
+//#endregion
+//#region src/machines/forgotPassword/actor.ts
+/**
+* @internal
+*/
+const forgotPasswordActor = (handlers, overridesContext) => {
+	return setup({
+		types: {
+			context: {},
+			events: {}
+		},
+		guards: {
+			shouldResetPassword: ({ context, event }) => shouldResetPassword(context, event),
+			shouldConfirmResetPassword: ({ context, event }) => shouldConfirmResetPassword(context, event),
+			hasCompletedResetPassword: ({ event }) => hasCompletedResetPassword(event)
+		},
+		actors: {
+			resetPassword: fromPromise(({ input }) => handlers.resetPassword(input)),
+			confirmResetPassword: fromPromise(({ input }) => handlers.confirmResetPassword(input))
+		},
+		actions: {
+			sendUpdate: sendParent({ type: "CHILD_CHANGED" }),
+			setCodeDeliveryDetails: assign({ codeDeliveryDetails: setCodeDeliveryDetails }),
+			setNextResetPasswordStep: assign({ step: setNextResetPasswordStep }),
+			setSignInStep: assign({ step: setNextSignInStep }),
+			setUsername: assign({ username: setUsername }),
+			setRemoteError: assign({ remoteError: setRemoteError }),
+			clearError: assign({ remoteError: void 0 })
+		}
+	}).createMachine({
+		id: "forgotPasswordActor",
+		initial: "init",
+		context: ({ input }) => ({
+			step: "FORGOT_PASSWORD",
+			...overridesContext,
+			...input
+		}),
+		states: {
+			init: { always: [
+				{
+					guard: "shouldResetPassword",
+					target: "#forgotPasswordActor.confirmResetPassword"
+				},
+				{
+					guard: "shouldConfirmResetPassword",
+					target: "#forgotPasswordActor.confirmResetPassword"
+				},
+				{ target: "#forgotPasswordActor.forgotPassword" }
+			] },
+			forgotPassword: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: { SUBMIT: { target: "submit" } }
+					},
+					submit: {
+						tags: "pending",
+						entry: [
+							"sendUpdate",
+							"setUsername",
+							"clearError"
+						],
+						invoke: {
+							src: "resetPassword",
+							input: ({ context: { username } }) => ({ username }),
+							onDone: [{
+								actions: ["setCodeDeliveryDetails", "setNextResetPasswordStep"],
+								target: "#forgotPasswordActor.confirmResetPassword"
+							}],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			confirmResetPassword: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							RESEND: { target: "resendCode" }
+						}
+					},
+					resendCode: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "resetPassword",
+							input: ({ context: { username } }) => ({ username }),
+							onDone: { target: "idle" },
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmResetPassword",
+							input: ({ context, event }) => ({
+								username: context.username,
+								...event.data
+							}),
+							onDone: [{
+								guard: "hasCompletedResetPassword",
+								actions: "setNextResetPasswordStep",
+								target: "#forgotPasswordActor.resolved"
+							}, {
+								actions: "setSignInStep",
+								target: "#forgotPasswordActor.resolved"
+							}],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			resolved: { type: "final" }
+		},
+		output: ({ context }) => context
+	});
+};
+
+//#endregion
+//#region src/machines/signOut/actor.ts
+/**
+* @internal
+*/
+const signOutActor = (handlers) => {
+	return setup({
+		types: { context: {} },
+		actors: { signOut: fromPromise(() => handlers.signOut()) }
+	}).createMachine({
+		id: "signOutActor",
+		initial: "pending",
+		context: {},
+		states: {
+			pending: {
+				tags: "pending",
+				invoke: {
+					src: "signOut",
+					onDone: "resolved",
+					onError: "rejected"
+				}
+			},
+			resolved: { type: "final" },
+			rejected: { type: "final" }
+		},
+		output: ({ context }) => context
+	});
+};
+
+//#endregion
+//#region src/machines/signUp/actor.ts
+/**
+* @internal
+*/
+const signUpActor = (handlers, overridesContext) => {
+	return setup({
+		types: {
+			context: {},
+			events: {}
+		},
+		guards: {
+			hasCompletedSignIn: ({ event }) => hasCompletedSignIn(event),
+			hasCompletedSignUp: ({ event }) => hasCompletedSignUp(event),
+			isUserAlreadyConfirmed: ({ event }) => isUserAlreadyConfirmed(event),
+			shouldAutoSignIn: ({ event }) => shouldAutoSignIn(event),
+			shouldConfirmSignInWithNewPassword: ({ event }) => shouldConfirmSignInWithNewPassword(event),
+			shouldConfirmSignUp: ({ context: { step } }) => step === "CONFIRM_SIGN_UP",
+			shouldConfirmSignUpFromSignIn: ({ event }) => shouldConfirmSignUpFromSignIn(event),
+			shouldResetPasswordFromSignIn: ({ event }) => shouldResetPasswordFromSignIn(event),
+			shouldVerifyAttribute: ({ event }) => shouldVerifyAttribute(event)
+		},
+		actors: {
+			autoSignIn: fromPromise(() => handlers.autoSignIn()),
+			confirmSignUp: fromPromise(({ input }) => handlers.confirmSignUp(input)),
+			fetchUserAttributes: fromPromise(() => handlers.fetchUserAttributes()),
+			resetPassword: fromPromise(({ input }) => handlers.resetPassword(input)),
+			resendSignUpCode: fromPromise(({ input }) => handlers.resendSignUpCode(input)),
+			signUp: fromPromise(({ input }) => handlers.signUp(input)),
+			signInWithRedirect: fromPromise(({ input }) => handlers.signInWithRedirect(input))
+		},
+		actions: {
+			sendUpdate: sendParent({ type: "CHILD_CHANGED" }),
+			setShouldVerifyUserAttributeStep: assign({ unverifiedUserAttributes: setUnverifiedUserAttributes }),
+			setConfirmAttributeCompleteStep: assign({ step: "CONFIRM_ATTRIBUTE_COMPLETE" }),
+			setCodeDeliveryDetails: assign({ codeDeliveryDetails: setCodeDeliveryDetails }),
+			setNextSignUpStep: assign({ step: setNextSignUpStep }),
+			setUsername: assign({ username: setUsername }),
+			setRemoteError: assign({ remoteError: setRemoteError }),
+			clearError: assign({ remoteError: void 0 })
+		}
+	}).createMachine({
+		id: "signUpActor",
+		initial: "init",
+		context: ({ input }) => ({
+			step: "SIGN_UP",
+			...overridesContext,
+			...input
+		}),
+		states: {
+			init: { always: [{
+				guard: "shouldConfirmSignUp",
+				target: "confirmSignUp"
+			}, { target: "#signUpActor.signUp" }] },
+			autoSignIn: {
+				tags: "pending",
+				invoke: {
+					src: "autoSignIn",
+					onDone: [
+						{
+							guard: "hasCompletedSignIn",
+							target: "#signUpActor.fetchUserAttributes"
+						},
+						{
+							guard: "shouldConfirmSignInWithNewPassword",
+							target: "#signUpActor.resolved"
+						},
+						{
+							guard: "shouldResetPasswordFromSignIn",
+							target: "#signUpActor.resetPassword"
+						},
+						{
+							guard: "shouldConfirmSignUpFromSignIn",
+							target: "#signUpActor.resendSignUpCode"
+						},
+						{ target: "#signUpActor.resolved" }
+					],
+					onError: { target: "#signUpActor.resolved" }
+				}
+			},
+			fetchUserAttributes: { invoke: {
+				src: "fetchUserAttributes",
+				onDone: [{
+					guard: "shouldVerifyAttribute",
+					actions: ["setShouldVerifyUserAttributeStep", "setConfirmAttributeCompleteStep"],
+					target: "#signUpActor.resolved"
+				}, {
+					actions: "setConfirmAttributeCompleteStep",
+					target: "#signUpActor.resolved"
+				}],
+				onError: {
+					actions: "setConfirmAttributeCompleteStep",
+					target: "#signUpActor.resolved"
+				}
+			} },
+			federatedSignIn: {
+				entry: ["sendUpdate", "clearError"],
+				invoke: {
+					src: "signInWithRedirect",
+					input: ({ event }) => event.data,
+					onDone: "signUp",
+					onError: {
+						actions: "setRemoteError",
+						target: "#signUpActor.signUp"
+					}
+				}
+			},
+			resetPassword: { invoke: {
+				src: "resetPassword",
+				input: ({ event }) => event.data,
+				onDone: {
+					actions: "setCodeDeliveryDetails",
+					target: "#signUpActor.resolved"
+				},
+				onError: { actions: "setRemoteError" }
+			} },
+			resendSignUpCode: {
+				tags: "pending",
+				entry: "sendUpdate",
+				exit: "sendUpdate",
+				invoke: {
+					src: "resendSignUpCode",
+					input: ({ context: { username }, event }) => ({
+						username,
+						...event.data
+					}),
+					onDone: {
+						actions: "setCodeDeliveryDetails",
+						target: "#signUpActor.confirmSignUp"
+					},
+					onError: [{
+						guard: "isUserAlreadyConfirmed",
+						target: "#signUpActor.resolved"
+					}, { actions: "setRemoteError" }]
+				}
+			},
+			signUp: {
+				initial: "idle",
+				exit: "clearError",
+				on: { FEDERATED_SIGN_IN: { target: "#signUpActor.federatedSignIn" } },
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: { SUBMIT: { target: "submit" } }
+					},
+					submit: {
+						tags: "pending",
+						entry: [
+							"sendUpdate",
+							"setUsername",
+							"clearError"
+						],
+						invoke: {
+							src: "signUp",
+							input: ({ event }) => event.data,
+							onDone: [
+								{
+									guard: "hasCompletedSignUp",
+									actions: "setNextSignUpStep",
+									target: "#signUpActor.resolved"
+								},
+								{
+									guard: "shouldAutoSignIn",
+									actions: "setNextSignUpStep",
+									target: "#signUpActor.autoSignIn"
+								},
+								{
+									actions: ["setCodeDeliveryDetails", "setNextSignUpStep"],
+									target: "#signUpActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			confirmSignUp: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							RESEND: { target: "#signUpActor.resendSignUpCode" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmSignUp",
+							input: ({ context: { username }, event }) => ({
+								username,
+								...event.data
+							}),
+							onDone: [
+								{
+									guard: "hasCompletedSignUp",
+									actions: "setNextSignUpStep",
+									target: "#signUpActor.resolved"
+								},
+								{
+									guard: "shouldAutoSignIn",
+									actions: "setNextSignUpStep",
+									target: "#signUpActor.autoSignIn"
+								},
+								{
+									actions: "setNextSignUpStep",
+									target: "#signUpActor.init"
+								}
+							],
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			resolved: { type: "final" }
+		},
+		output: ({ context }) => context
+	});
+};
+
+//#endregion
+//#region src/machines/verifyUserAttributes/actor.ts
+/**
+* @internal
+*/
+const verifyUserAttributesActor = (handlers, overridesContext) => {
+	return setup({
+		types: {
+			context: {},
+			events: {}
+		},
+		guards: {},
+		actors: {
+			sendUserAttributeVerificationCode: fromPromise(({ input }) => handlers.sendUserAttributeVerificationCode(input)),
+			confirmVerifyUserAttribute: fromPromise(({ input }) => handlers.confirmUserAttribute(input))
+		},
+		actions: {
+			sendUpdate: sendParent({ type: "CHILD_CHANGED" }),
+			setCodeDeliveryDetails: assign({ codeDeliveryDetails: setCodeDeliveryDetails }),
+			setSelectedUserAttribute: assign({ selectedUserAttribute: setSelectedUserAttribute }),
+			setConfirmAttributeCompleteStep: assign({ step: setConfirmAttributeCompleteStep }),
+			setRemoteError: assign({ remoteError: setRemoteError }),
+			clearError: assign({ remoteError: void 0 }),
+			clearSelectedUserAttribute: assign({ selectedUserAttribute: void 0 })
+		}
+	}).createMachine({
+		id: "vefiryUserAttributesActor",
+		initial: "selectUserAttributes",
+		context: ({ input }) => ({
+			step: "SIGN_IN",
+			...overridesContext,
+			...input
+		}),
+		states: {
+			selectUserAttributes: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SKIP: { target: "#vefiryUserAttributesActor.resolved" },
+							SUBMIT: { target: "submit" }
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "sendUserAttributeVerificationCode",
+							input: ({ event }) => event.data,
+							onDone: {
+								actions: ["setSelectedUserAttribute", "setCodeDeliveryDetails"],
+								target: "#vefiryUserAttributesActor.confirmVerifyUserAttribute"
+							},
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			confirmVerifyUserAttribute: {
+				initial: "idle",
+				exit: "clearError",
+				states: {
+					idle: {
+						entry: "sendUpdate",
+						on: {
+							SUBMIT: { target: "submit" },
+							RESEND: { target: "resendCode" },
+							SKIP: { target: "#vefiryUserAttributesActor.resolved" }
+						}
+					},
+					resendCode: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "sendUserAttributeVerificationCode",
+							input: ({ context, event }) => ({
+								userAttributeKey: context.selectedUserAttribute,
+								...event.data
+							}),
+							onDone: { target: "idle" },
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					},
+					submit: {
+						tags: "pending",
+						entry: ["sendUpdate", "clearError"],
+						invoke: {
+							src: "confirmVerifyUserAttribute",
+							input: ({ context, event }) => ({
+								userAttributeKey: context.selectedUserAttribute,
+								...event.data
+							}),
+							onDone: {
+								actions: ["setConfirmAttributeCompleteStep", "clearSelectedUserAttribute"],
+								target: "#vefiryUserAttributesActor.resolved"
+							},
+							onError: {
+								actions: "setRemoteError",
+								target: "idle"
+							}
+						}
+					}
+				}
+			},
+			resolved: { type: "final" }
+		},
+		output: ({ context }) => context
+	});
+};
+
+//#endregion
+//#region src/machines/index.ts
+/**
+* @internal
+*/
+const createAuthenticatorMachine = (options) => {
+	const { handlers: customHandlers,...config } = options ?? {};
+	const handlers = {
+		...defaultHandlers,
+		...customHandlers
+	};
+	return setup({
+		types: {
+			context: {},
+			events: {}
+		},
+		guards: {
+			hasCompletedAttributeConfirmation: ({ event: { output } }) => hasCompletedAttributeConfirmation(output?.step),
+			hasUser: ({ context }) => !!context.user,
+			isInitialStateSignUp: ({ context }) => context.config?.initialState === "signUp",
+			isInitialStateResetPassword: ({ context }) => context.config?.initialState === "forgotPassword",
+			isConfirmSignUpStep: ({ event: { output } }) => isConfirmSignUpStep(output?.step),
+			isConfirmUserAttributeStep: ({ event: { output } }) => isConfirmUserAttributeStep(output?.step),
+			isShouldConfirmUserAttributeStep: ({ event: { output } }) => isShouldConfirmUserAttributeStep(output?.step),
+			isResetPasswordStep: ({ event: { output } }) => isResetPasswordStep(output?.step)
+		},
+		actors: {
+			getCurrentUser: fromPromise(() => handlers.getCurrentUser()),
+			invokeSignInActor: signInActor(handlers),
+			invokeSignUpActor: signUpActor(handlers),
+			invokeForgotPasswordActor: forgotPasswordActor(handlers),
+			invokeVerifyUserAttributesActor: verifyUserAttributesActor(handlers),
+			invokeSignOutActor: signOutActor(handlers)
+		},
+		actions: {
+			clearActorDoneData: assign({ actorDoneData: void 0 }),
+			clearUser: assign({ user: void 0 }),
+			forwardToActor: forwardTo("childActor"),
+			setUser: assign({ user: ({ event }) => event.output }),
+			setActorDoneData: assign({ actorDoneData: ({ event }) => event.output })
+		}
+	}).createMachine({
+		id: "authenticator",
+		initial: "idle",
+		context: {
+			config,
+			user: void 0
+		},
+		states: {
+			idle: { invoke: {
+				src: "getCurrentUser",
+				onDone: {
+					actions: "setUser",
+					target: "#authenticator.setup"
+				},
+				onError: { target: "#authenticator.setup" }
+			} },
+			setup: {
+				initial: "init",
+				states: { init: { always: [
+					{
+						guard: "hasUser",
+						target: "#authenticator.authenticated"
+					},
+					{
+						guard: "isInitialStateSignUp",
+						target: "#authenticator.signUpActor"
+					},
+					{
+						guard: "isInitialStateResetPassword",
+						target: "#authenticator.forgotPasswordActor"
+					},
+					{ target: "#authenticator.signInActor" }
+				] } }
+			},
+			getCurrentUser: { invoke: {
+				src: "getCurrentUser",
+				onDone: {
+					actions: "setUser",
+					target: "#authenticator.authenticated"
+				},
+				onError: { target: "setup" }
+			} },
+			signInActor: {
+				invoke: {
+					id: "childActor",
+					src: "invokeSignInActor",
+					input: ({ context }) => context.actorDoneData,
+					onDone: [
+						{
+							guard: "hasCompletedAttributeConfirmation",
+							target: "#authenticator.getCurrentUser"
+						},
+						{
+							guard: "isShouldConfirmUserAttributeStep",
+							actions: "setActorDoneData",
+							target: "#authenticator.verifyUserAttributesActor"
+						},
+						{
+							guard: "isResetPasswordStep",
+							actions: "setActorDoneData",
+							target: "#authenticator.forgotPasswordActor"
+						},
+						{
+							guard: "isConfirmSignUpStep",
+							actions: "setActorDoneData",
+							target: "#authenticator.signUpActor"
+						}
+					]
+				},
+				entry: "clearActorDoneData",
+				on: {
+					FORGOT_PASSWORD: { target: "#authenticator.forgotPasswordActor" },
+					SIGN_IN: { target: "#authenticator.signInActor" },
+					SIGN_UP: { target: "#authenticator.signUpActor" },
+					FEDERATED_SIGN_IN: { actions: "forwardToActor" },
+					SUBMIT: { actions: "forwardToActor" }
+				}
+			},
+			signUpActor: {
+				invoke: {
+					id: "childActor",
+					src: "invokeSignUpActor",
+					input: ({ context }) => context.actorDoneData,
+					onDone: [
+						{
+							guard: "hasCompletedAttributeConfirmation",
+							actions: "clearActorDoneData",
+							target: "#authenticator.getCurrentUser"
+						},
+						{
+							guard: "isShouldConfirmUserAttributeStep",
+							actions: "setActorDoneData",
+							target: "#authenticator.verifyUserAttributesActor"
+						},
+						{
+							guard: "isConfirmUserAttributeStep",
+							actions: "clearActorDoneData",
+							target: "#authenticator.verifyUserAttributesActor"
+						},
+						{
+							actions: "setActorDoneData",
+							target: "#authenticator.signInActor"
+						}
+					]
+				},
+				on: {
+					SIGN_IN: { target: "#authenticator.signInActor" },
+					FEDERATED_SIGN_IN: { actions: "forwardToActor" },
+					RESEND: { actions: "forwardToActor" },
+					SUBMIT: { actions: "forwardToActor" }
+				}
+			},
+			forgotPasswordActor: {
+				invoke: {
+					id: "childActor",
+					src: "invokeForgotPasswordActor",
+					input: ({ context }) => context.actorDoneData,
+					onDone: { target: "#authenticator.signInActor" }
+				},
+				exit: "clearActorDoneData",
+				on: {
+					SIGN_IN: { target: "#authenticator.signInActor" },
+					RESEND: { actions: "forwardToActor" },
+					SUBMIT: { actions: "forwardToActor" }
+				}
+			},
+			verifyUserAttributesActor: {
+				invoke: {
+					id: "childActor",
+					src: "invokeVerifyUserAttributesActor",
+					input: ({ context }) => context.actorDoneData,
+					onDone: {
+						actions: "setActorDoneData",
+						target: "#authenticator.getCurrentUser"
+					}
+				},
+				on: {
+					SKIP: { actions: "forwardToActor" },
+					RESEND: { actions: "forwardToActor" },
+					SUBMIT: { actions: "forwardToActor" }
+				}
+			},
+			authenticated: {
+				initial: "idle",
+				on: { SIGN_OUT: "signOut" },
+				states: {
+					idle: { on: { TOKEN_REFRESH: "refreshUser" } },
+					refreshUser: { invoke: {
+						src: "getCurrentUser",
+						onDone: {
+							actions: "setUser",
+							target: "idle"
+						},
+						onError: { target: "#authenticator.signOut" }
+					} }
+				}
+			},
+			signOut: {
+				invoke: {
+					id: "childActor",
+					src: "invokeSignOutActor",
+					onDone: {
+						actions: "clearUser",
+						target: "#authenticator.setup"
+					}
+				},
+				exit: "clearActorDoneData"
+			}
+		},
+		on: {
+			CHILD_CHANGED: { actions: assign(({ context }) => context) },
+			SIGN_IN_WITH_REDIRECT: { target: "#authenticator.getCurrentUser" }
+		}
+	});
+};
+
+//#endregion
+export { createAuthenticatorMachine };
+//# sourceMappingURL=machines-CRIehDHl.js.map