@jskit-ai/auth-web 0.1.8 → 0.1.10

package/src/client/composables/loginView/useLoginViewState.js

@@ -0,0 +1,262 @@
+import { computed, ref } from "vue";
+import {
+  resolveSurfaceIdFromPlacementPathname,
+  resolveSurfaceRootPathFromPlacementContext
+} from "@jskit-ai/shell-web/client/placement";
+import {
+  normalizeAuthReturnToPath,
+  resolveAllowedReturnToOriginsFromPlacementContext
+} from "../../lib/returnToPath.js";
+import {
+  LOGIN_MODE,
+  REGISTER_MODE,
+  FORGOT_MODE,
+  OTP_MODE,
+  EMAIL_CONFIRMATION_MODE,
+  AUTH_TITLE_BY_MODE,
+  AUTH_SUBTITLE_BY_MODE,
+  SUBMIT_LABEL_BY_MODE
+} from "./constants.js";
+import { normalizeEmailAddress, maskEmail } from "./identityHelpers.js";
+import {
+  createRememberedAccountHint,
+  writeRememberedAccountHint,
+  clearRememberedAccountHint
+} from "./rememberedAccountStorage.js";
+
+export function useLoginViewState({ placementContext } = {}) {
+  const mode = ref(LOGIN_MODE);
+  const email = ref("");
+  const password = ref("");
+  const confirmPassword = ref("");
+  const otpCode = ref("");
+  const showPassword = ref(false);
+  const showConfirmPassword = ref(false);
+  const emailTouched = ref(false);
+  const passwordTouched = ref(false);
+  const confirmPasswordTouched = ref(false);
+  const otpCodeTouched = ref(false);
+  const submitAttempted = ref(false);
+  const rememberAccountOnDevice = ref(true);
+  const rememberedAccount = ref(null);
+  const useRememberedAccount = ref(false);
+  const oauthProviders = ref([]);
+  const oauthDefaultProvider = ref("");
+  const loading = ref(false);
+  const otpRequestPending = ref(false);
+  const registerConfirmationResendPending = ref(false);
+  const errorMessage = ref("");
+  const infoMessage = ref("");
+  const pendingEmailConfirmationMessage = ref("");
+  const pendingEmailConfirmationAddress = ref("");
+
+  const isLogin = computed(() => mode.value === LOGIN_MODE);
+  const isRegister = computed(() => mode.value === REGISTER_MODE);
+  const isForgot = computed(() => mode.value === FORGOT_MODE);
+  const isOtp = computed(() => mode.value === OTP_MODE);
+  const isEmailConfirmationPending = computed(() => mode.value === EMAIL_CONFIRMATION_MODE);
+  const showRememberedAccount = computed(
+    () => (isLogin.value || isOtp.value) && useRememberedAccount.value && Boolean(rememberedAccount.value)
+  );
+  const rememberedAccountDisplayName = computed(() => String(rememberedAccount.value?.displayName || "your account"));
+  const rememberedAccountMaskedEmail = computed(() => String(rememberedAccount.value?.maskedEmail || ""));
+  const rememberedAccountSwitchLabel = "Use another account";
+  const authTitle = computed(() => AUTH_TITLE_BY_MODE[mode.value] || AUTH_TITLE_BY_MODE[LOGIN_MODE]);
+  const authSubtitle = computed(() => {
+    if (isEmailConfirmationPending.value) {
+      const maskedEmail = maskEmail(pendingEmailConfirmationAddress.value);
+      if (maskedEmail) {
+        return `Open the confirmation link sent to ${maskedEmail} to finish signing in.`;
+      }
+      return "Open the confirmation link from your inbox to finish signing in.";
+    }
+    return AUTH_SUBTITLE_BY_MODE[mode.value] || AUTH_SUBTITLE_BY_MODE[LOGIN_MODE];
+  });
+  const submitLabel = computed(() => SUBMIT_LABEL_BY_MODE[mode.value] || SUBMIT_LABEL_BY_MODE[LOGIN_MODE]);
+  const allowedReturnToOrigins = computed(() =>
+    resolveAllowedReturnToOriginsFromPlacementContext(placementContext?.value)
+  );
+  const requestedReturnTo = ref(
+    normalizeAuthReturnToPath(
+      typeof window === "object" ? new URLSearchParams(window.location.search || "").get("returnTo") : "/",
+      "/",
+      {
+        allowedOrigins: allowedReturnToOrigins.value
+      }
+    )
+  );
+  const mainScreenPath = computed(() => {
+    const normalizedReturnTo = normalizeAuthReturnToPath(requestedReturnTo.value, "/", {
+      allowedOrigins: allowedReturnToOrigins.value
+    });
+    const surfaceId = resolveSurfaceIdFromPlacementPathname(placementContext?.value, normalizedReturnTo);
+    const rootPath = resolveSurfaceRootPathFromPlacementContext(placementContext?.value, surfaceId || "");
+    return normalizeAuthReturnToPath(rootPath, "/", {
+      allowedOrigins: allowedReturnToOrigins.value
+    });
+  });
+  const emailConfirmationMessage = computed(
+    () =>
+      String(pendingEmailConfirmationMessage.value || "").trim() ||
+      "Please confirm your email address. After confirmation, you can sign in."
+  );
+
+  function clearTransientMessages() {
+    errorMessage.value = "";
+    infoMessage.value = "";
+  }
+
+  function resetTransientValidationState() {
+    submitAttempted.value = false;
+    emailTouched.value = false;
+    passwordTouched.value = false;
+    confirmPasswordTouched.value = false;
+    otpCodeTouched.value = false;
+  }
+
+  function clearRememberedAccountState() {
+    rememberedAccount.value = null;
+    useRememberedAccount.value = false;
+  }
+
+  function resetCredentialFields() {
+    password.value = "";
+    confirmPassword.value = "";
+    otpCode.value = "";
+    showPassword.value = false;
+    showConfirmPassword.value = false;
+  }
+
+  function resolveNormalizedEmail() {
+    return normalizeEmailAddress(email.value);
+  }
+
+  function applyRememberedAccountHint(hint) {
+    if (!hint) {
+      clearRememberedAccountState();
+      return;
+    }
+
+    rememberedAccount.value = hint;
+    useRememberedAccount.value = true;
+    rememberAccountOnDevice.value = true;
+    email.value = String(hint.email || "").trim();
+  }
+
+  function applyRememberedAccountPreference({ email: accountEmail, displayName, shouldRemember } = {}) {
+    const rememberedHint = createRememberedAccountHint({
+      email: accountEmail,
+      displayName,
+      lastUsedAt: new Date().toISOString()
+    });
+
+    if (shouldRemember && rememberedHint) {
+      writeRememberedAccountHint(rememberedHint);
+      applyRememberedAccountHint(rememberedHint);
+      return;
+    }
+
+    clearRememberedAccountHint();
+    clearRememberedAccountState();
+  }
+
+  function switchAccount() {
+    clearRememberedAccountHint();
+    clearRememberedAccountState();
+    rememberAccountOnDevice.value = false;
+    mode.value = LOGIN_MODE;
+    email.value = "";
+    resetCredentialFields();
+    clearTransientMessages();
+    resetTransientValidationState();
+  }
+
+  function switchMode(nextMode) {
+    if (nextMode === mode.value) {
+      return;
+    }
+
+    mode.value = nextMode;
+    resetCredentialFields();
+    registerConfirmationResendPending.value = false;
+    if (nextMode !== EMAIL_CONFIRMATION_MODE) {
+      pendingEmailConfirmationAddress.value = "";
+      pendingEmailConfirmationMessage.value = "";
+    }
+    clearTransientMessages();
+    resetTransientValidationState();
+
+    if (nextMode !== LOGIN_MODE && nextMode !== OTP_MODE) {
+      useRememberedAccount.value = false;
+      return;
+    }
+
+    if (rememberedAccount.value) {
+      useRememberedAccount.value = true;
+    }
+  }
+
+  function enterEmailConfirmationPendingState({ emailAddress = "", message = "" } = {}) {
+    switchMode(EMAIL_CONFIRMATION_MODE);
+    pendingEmailConfirmationAddress.value = normalizeEmailAddress(emailAddress);
+    pendingEmailConfirmationMessage.value = String(message || "").trim();
+  }
+
+  function goToMainScreen() {
+    if (typeof window !== "object" || !window.location || typeof window.location.assign !== "function") {
+      return;
+    }
+    window.location.assign(mainScreenPath.value);
+  }
+
+  return {
+    mode,
+    email,
+    password,
+    confirmPassword,
+    otpCode,
+    showPassword,
+    showConfirmPassword,
+    emailTouched,
+    passwordTouched,
+    confirmPasswordTouched,
+    otpCodeTouched,
+    submitAttempted,
+    rememberAccountOnDevice,
+    rememberedAccount,
+    useRememberedAccount,
+    oauthProviders,
+    oauthDefaultProvider,
+    loading,
+    otpRequestPending,
+    registerConfirmationResendPending,
+    errorMessage,
+    infoMessage,
+    pendingEmailConfirmationMessage,
+    pendingEmailConfirmationAddress,
+    isLogin,
+    isRegister,
+    isForgot,
+    isOtp,
+    isEmailConfirmationPending,
+    showRememberedAccount,
+    rememberedAccountDisplayName,
+    rememberedAccountMaskedEmail,
+    rememberedAccountSwitchLabel,
+    authTitle,
+    authSubtitle,
+    submitLabel,
+    allowedReturnToOrigins,
+    requestedReturnTo,
+    mainScreenPath,
+    emailConfirmationMessage,
+    resolveNormalizedEmail,
+    applyRememberedAccountHint,
+    applyRememberedAccountPreference,
+    clearTransientMessages,
+    switchMode,
+    switchAccount,
+    enterEmailConfirmationPendingState,
+    goToMainScreen
+  };
+}

package/src/client/composables/loginView/useLoginViewValidation.js

@@ -0,0 +1,124 @@
+import { computed } from "vue";
+import { authRegisterCommand } from "@jskit-ai/auth-core/shared/commands/authRegisterCommand";
+import { authLoginPasswordCommand } from "@jskit-ai/auth-core/shared/commands/authLoginPasswordCommand";
+import { authLoginOtpRequestCommand } from "@jskit-ai/auth-core/shared/commands/authLoginOtpRequestCommand";
+import { authLoginOtpVerifyCommand } from "@jskit-ai/auth-core/shared/commands/authLoginOtpVerifyCommand";
+import { authPasswordResetRequestCommand } from "@jskit-ai/auth-core/shared/commands/authPasswordResetRequestCommand";
+import {
+  validateCommandSection,
+  resolveFieldValidationMessage
+} from "./validationHelpers.js";
+
+export function useLoginViewValidation({ state } = {}) {
+  function resolveFieldErrorMessages({
+    shouldValidate,
+    commandResource,
+    section = "bodyValidator",
+    payload,
+    fieldName
+  } = {}) {
+    if (!shouldValidate) {
+      return [];
+    }
+
+    const parsed = validateCommandSection(commandResource, section, payload);
+    const message = resolveFieldValidationMessage(parsed, fieldName);
+    return message ? [message] : [];
+  }
+
+  const emailErrorMessages = computed(() => {
+    const shouldValidate = state.submitAttempted.value || state.emailTouched.value;
+    const normalizedEmail = state.resolveNormalizedEmail();
+    const command = state.isRegister.value
+      ? authRegisterCommand
+      : state.isForgot.value
+        ? authPasswordResetRequestCommand
+        : state.isOtp.value
+          ? authLoginOtpRequestCommand
+          : authLoginPasswordCommand;
+    const payload = state.isRegister.value || state.isLogin.value
+      ? {
+          email: normalizedEmail,
+          password: String(state.password.value || "")
+        }
+      : {
+          email: normalizedEmail
+        };
+
+    return resolveFieldErrorMessages({
+      shouldValidate,
+      commandResource: command,
+      payload,
+      fieldName: "email"
+    });
+  });
+
+  const passwordErrorMessages = computed(() => {
+    const shouldValidate = state.submitAttempted.value || state.passwordTouched.value;
+    if (!shouldValidate || state.isForgot.value || state.isOtp.value) {
+      return [];
+    }
+
+    const normalizedEmail = state.resolveNormalizedEmail();
+    const command = state.isRegister.value ? authRegisterCommand : authLoginPasswordCommand;
+    return resolveFieldErrorMessages({
+      shouldValidate: true,
+      commandResource: command,
+      payload: {
+        email: normalizedEmail,
+        password: String(state.password.value || "")
+      },
+      fieldName: "password"
+    });
+  });
+
+  const confirmPasswordErrorMessages = computed(() => {
+    const shouldValidate = state.submitAttempted.value || state.confirmPasswordTouched.value;
+    if (!shouldValidate || !state.isRegister.value) {
+      return [];
+    }
+    if (String(state.confirmPassword.value || "").trim() !== String(state.password.value || "").trim()) {
+      return ["Passwords do not match."];
+    }
+    return [];
+  });
+
+  const otpCodeErrorMessages = computed(() => {
+    const shouldValidate = state.submitAttempted.value || state.otpCodeTouched.value;
+    return resolveFieldErrorMessages({
+      shouldValidate: shouldValidate && state.isOtp.value,
+      commandResource: authLoginOtpVerifyCommand,
+      payload: {
+        token: String(state.otpCode.value || "").trim()
+      },
+      fieldName: "token"
+    });
+  });
+
+  const canSubmit = computed(() => {
+    if (state.isEmailConfirmationPending.value) {
+      return false;
+    }
+    if (state.loading.value) {
+      return false;
+    }
+    if (emailErrorMessages.value.length > 0) {
+      return false;
+    }
+    if (state.isRegister.value || state.isLogin.value) {
+      return passwordErrorMessages.value.length < 1 && confirmPasswordErrorMessages.value.length < 1;
+    }
+    if (state.isOtp.value) {
+      return otpCodeErrorMessages.value.length < 1;
+    }
+    return true;
+  });
+
+  return {
+    emailErrorMessages,
+    passwordErrorMessages,
+    confirmPasswordErrorMessages,
+    otpCodeErrorMessages,
+    canSubmit
+  };
+}

package/src/client/composables/loginView/validationHelpers.js

@@ -0,0 +1,65 @@
+import { validateOperationSection } from "@jskit-ai/http-runtime/shared/validators/operationValidation";
+
+function validateCommandSection(commandResource, section, payload) {
+  if (!commandResource || !commandResource.operation) {
+    return {
+      ok: true,
+      fieldErrors: {},
+      globalErrors: []
+    };
+  }
+
+  return validateOperationSection({
+    operation: commandResource.operation,
+    section,
+    value: payload
+  });
+}
+
+function resolveValidationMessage(validationResult, fallbackMessage = "Validation failed.") {
+  if (!validationResult || validationResult.ok) {
+    return "";
+  }
+
+  const fieldErrors = validationResult.fieldErrors && typeof validationResult.fieldErrors === "object"
+    ? validationResult.fieldErrors
+    : {};
+  const firstFieldError = Object.values(fieldErrors).find((entry) => String(entry || "").trim().length > 0);
+  if (firstFieldError) {
+    return String(firstFieldError);
+  }
+
+  const globalErrors = Array.isArray(validationResult.globalErrors) ? validationResult.globalErrors : [];
+  const firstGlobalError = globalErrors.find((entry) => String(entry || "").trim().length > 0);
+  if (firstGlobalError) {
+    return String(firstGlobalError);
+  }
+
+  return String(fallbackMessage || "Validation failed.");
+}
+
+function resolveFieldValidationMessage(validationResult, fieldName = "") {
+  if (!validationResult || validationResult.ok) {
+    return "";
+  }
+
+  const fieldErrors = validationResult.fieldErrors && typeof validationResult.fieldErrors === "object"
+    ? validationResult.fieldErrors
+    : {};
+  return String(fieldErrors[fieldName] || "").trim();
+}
+
+function ensureCommandSectionValid(commandResource, section, payload, fallbackMessage) {
+  const validation = validateCommandSection(commandResource, section, payload);
+  if (validation.ok) {
+    return;
+  }
+  throw new Error(resolveValidationMessage(validation, fallbackMessage));
+}
+
+export {
+  validateCommandSection,
+  resolveValidationMessage,
+  resolveFieldValidationMessage,
+  ensureCommandSectionValid
+};

package/src/client/runtime/authGuardRuntime.js

@@ -1,6 +1,8 @@
 import { isTransientQueryError } from "@jskit-ai/kernel/shared/support";
 import { AUTH_PATHS } from "@jskit-ai/auth-core/shared/authPaths";
 import { isExternalLinkTarget } from "@jskit-ai/kernel/shared/support/linkPath";
+import { normalizePathname as normalizeSurfacePathname } from "@jskit-ai/kernel/shared/surface/paths";
+import { createListenerSubscription } from "@jskit-ai/kernel/shared/support/listenerSet";
 
 const GLOBAL_GUARD_EVALUATOR_KEY = "__JSKIT_WEB_SHELL_GUARD_EVALUATOR__";
 const AUTH_POLICY_AUTHENTICATED = "authenticated";
@@ -9,6 +11,25 @@ const DEFAULT_LOGIN_ROUTE = "/auth/login";
 const DEFAULT_REFRESH_ON_FOREGROUND = false;
 const DEFAULT_REFRESH_ON_RECONNECT = false;
 const DEFAULT_REALTIME_REFRESH_EVENTS = Object.freeze(["users.bootstrap.changed", "auth.session.changed"]);
+const OAUTH_QUERY_PARAM_RETURN_TO = "returnTo";
+const OAUTH_CALLBACK_PARAM_KEYS = Object.freeze([
+  "code",
+  "access_token",
+  "refresh_token",
+  "provider_token",
+  "expires_in",
+  "expires_at",
+  "token_type",
+  "state",
+  "sb",
+  "type",
+  "error",
+  "error_code",
+  "error_description",
+  "errorCode",
+  "errorDescription",
+  "token_hash"
+]);
 const KEEP_PREVIOUS_AUTH_STATE = Symbol("keepPreviousAuthState");
 const DEFAULT_AUTH_STATE = Object.freeze({
   authenticated: false,
@@ -26,13 +47,11 @@ function asGlobalObject() {
 
 function normalizePathname(pathname, fallback = "/") {
   const raw = String(pathname || "").trim();
-  if (!raw || !raw.startsWith("/")) {
+  if (!raw || !raw.startsWith("/") || raw.startsWith("//")) {
     return fallback;
   }
-  if (raw.startsWith("//")) {
-    return fallback;
-  }
-  return raw;
+
+  return normalizeSurfacePathname(raw);
 }
 
 function normalizeLoginRoute(loginRoute, fallback = DEFAULT_LOGIN_ROUTE) {
@@ -247,6 +266,60 @@ function normalizeRuntimePath(value, fallback) {
   return raw || fallback;
 }
 
+function hasOAuthCallbackParams({ search = "", hash = "" } = {}) {
+  const searchParams = new URLSearchParams(String(search || ""));
+  const hashParams = new URLSearchParams(String(hash || "").replace(/^#/, ""));
+  return OAUTH_CALLBACK_PARAM_KEYS.some((key) => searchParams.has(key) || hashParams.has(key));
+}
+
+function stripOAuthCallbackParamsFromSearch(search = "") {
+  const params = new URLSearchParams(String(search || ""));
+  OAUTH_CALLBACK_PARAM_KEYS.forEach((key) => {
+    params.delete(key);
+  });
+  params.delete(OAUTH_QUERY_PARAM_RETURN_TO);
+  return params;
+}
+
+function redirectOAuthCallbackToLoginRoute(loginRoute) {
+  if (
+    typeof window !== "object" ||
+    !window ||
+    !window.location ||
+    typeof window.location.replace !== "function"
+  ) {
+    return false;
+  }
+
+  const normalizedLoginRoute = normalizeLoginRoute(loginRoute, DEFAULT_LOGIN_ROUTE);
+  if (isExternalLinkTarget(normalizedLoginRoute)) {
+    return false;
+  }
+
+  const currentPathname = normalizePathname(window.location.pathname || "", "/");
+  const loginPathname = normalizePathname(normalizedLoginRoute, DEFAULT_LOGIN_ROUTE);
+  if (currentPathname === loginPathname) {
+    return false;
+  }
+
+  const currentSearch = String(window.location.search || "");
+  const currentHash = String(window.location.hash || "");
+  if (!hasOAuthCallbackParams({ search: currentSearch, hash: currentHash })) {
+    return false;
+  }
+
+  const returnToParams = stripOAuthCallbackParamsFromSearch(currentSearch);
+  const returnToQuery = returnToParams.toString();
+  const returnTo = `${currentPathname}${returnToQuery ? `?${returnToQuery}` : ""}`;
+
+  const nextParams = new URLSearchParams(currentSearch);
+  nextParams.set(OAUTH_QUERY_PARAM_RETURN_TO, returnTo);
+  const nextQuery = nextParams.toString();
+  const nextPath = `${loginPathname}${nextQuery ? `?${nextQuery}` : ""}${currentHash}`;
+  window.location.replace(nextPath);
+  return true;
+}
+
 function asEventTarget(value) {
   if (!value || typeof value !== "object") {
     return null;
@@ -335,6 +408,7 @@ function createAuthGuardRuntime({
   let activeRefreshPromise = null;
   let listenersInstalled = false;
   const listeners = new Set();
+  const subscribe = createListenerSubscription(listeners);
 
   function notifyListeners() {
     for (const listener of listeners) {
@@ -350,16 +424,6 @@ function createAuthGuardRuntime({
     return authState;
   }
 
-  function subscribe(listener) {
-    if (typeof listener !== "function") {
-      return () => {};
-    }
-    listeners.add(listener);
-    return () => {
-      listeners.delete(listener);
-    };
-  }
-
   async function refresh({ sessionPath: nextSessionPath } = {}) {
     currentSessionPath = normalizeRuntimePath(nextSessionPath, currentSessionPath);
     if (activeRefreshPromise) {
@@ -392,6 +456,10 @@ function createAuthGuardRuntime({
   async function initialize({ sessionPath: nextSessionPath, loginRoute: nextLoginRoute } = {}) {
     currentSessionPath = normalizeRuntimePath(nextSessionPath, currentSessionPath);
     currentLoginRoute = normalizeLoginRoute(nextLoginRoute, currentLoginRoute);
+    if (redirectOAuthCallbackToLoginRoute(currentLoginRoute)) {
+      return authState;
+    }
+
     installGuardEvaluator({
       loginRoute: currentLoginRoute,
       getAuthState: () => authState

package/src/client/runtime/useLoginView.js

@@ -1,7 +1,73 @@
-import { useDefaultLoginView } from "../composables/useDefaultLoginView.js";
+import { onMounted } from "vue";
+import { useQueryClient } from "@tanstack/vue-query";
+import { useShellWebErrorRuntime } from "@jskit-ai/shell-web/client/error";
+import { useWebPlacementContext } from "@jskit-ai/shell-web/client/placement";
+import { useLoginViewState } from "../composables/loginView/useLoginViewState.js";
+import { useLoginViewValidation } from "../composables/loginView/useLoginViewValidation.js";
+import { useLoginViewActions } from "../composables/loginView/useLoginViewActions.js";
 
 function useLoginView() {
-  return useDefaultLoginView();
+  const { context: placementContext } = useWebPlacementContext();
+  const queryClient = useQueryClient();
+  const errorRuntime = useShellWebErrorRuntime();
+
+  const state = useLoginViewState({ placementContext });
+  const validation = useLoginViewValidation({ state });
+  const actions = useLoginViewActions({
+    state,
+    validation,
+    queryClient,
+    errorRuntime
+  });
+
+  onMounted(actions.initializeOnMounted);
+
+  return {
+    authTitle: state.authTitle,
+    authSubtitle: state.authSubtitle,
+    isForgot: state.isForgot,
+    isOtp: state.isOtp,
+    isLogin: state.isLogin,
+    isRegister: state.isRegister,
+    isEmailConfirmationPending: state.isEmailConfirmationPending,
+    emailConfirmationMessage: state.emailConfirmationMessage,
+    showRememberedAccount: state.showRememberedAccount,
+    switchMode: state.switchMode,
+    goToMainScreen: state.goToMainScreen,
+    submitAuth: actions.submitAuth,
+    rememberedAccountDisplayName: state.rememberedAccountDisplayName,
+    rememberedAccountMaskedEmail: state.rememberedAccountMaskedEmail,
+    rememberedAccountSwitchLabel: state.rememberedAccountSwitchLabel,
+    switchAccount: state.switchAccount,
+    email: state.email,
+    emailErrorMessages: validation.emailErrorMessages,
+    emailTouched: state.emailTouched,
+    password: state.password,
+    showPassword: state.showPassword,
+    passwordErrorMessages: validation.passwordErrorMessages,
+    passwordTouched: state.passwordTouched,
+    confirmPassword: state.confirmPassword,
+    showConfirmPassword: state.showConfirmPassword,
+    confirmPasswordErrorMessages: validation.confirmPasswordErrorMessages,
+    confirmPasswordTouched: state.confirmPasswordTouched,
+    otpCode: state.otpCode,
+    otpCodeErrorMessages: validation.otpCodeErrorMessages,
+    otpCodeTouched: state.otpCodeTouched,
+    rememberAccountOnDevice: state.rememberAccountOnDevice,
+    otpRequestPending: state.otpRequestPending,
+    registerConfirmationResendPending: state.registerConfirmationResendPending,
+    requestOtpCode: actions.requestOtpCode,
+    resendRegisterConfirmationEmail: actions.resendRegisterConfirmationEmail,
+    oauthProviders: state.oauthProviders,
+    loading: state.loading,
+    oauthProviderIcon: actions.oauthProviderIcon,
+    startOAuthSignIn: actions.startOAuthSignIn,
+    oauthProviderButtonLabel: actions.oauthProviderButtonLabel,
+    errorMessage: state.errorMessage,
+    infoMessage: state.infoMessage,
+    canSubmit: validation.canSubmit,
+    submitLabel: state.submitLabel
+  };
 }
 
-export { useLoginView, useDefaultLoginView };
+export { useLoginView };