@umituz/web-dashboard 5.0.0 → 6.0.0

package/src/domains/auth/utils/auth.ts

@@ -1,221 +0,0 @@
-/**
- * Auth Utilities
- *
- * Validation and helper functions for authentication.
- * Validation messages are i18n keys, not hardcoded strings —
- * the consumer renders the localized text in its UI layer.
- */
-
-import type { LoginCredentials, RegisterData, User } from "../types/auth";
-import { AUTH_VALIDATION_KEYS } from './validationKeys';
-
-export { generateResetToken } from './secureToken';
-export { AUTH_VALIDATION_KEYS } from './validationKeys';
-export type { AuthValidationKey } from './validationKeys';
-
-/**
- * Validation result type — error is now an i18n key.
- */
-export type ValidationResult =
-  | { valid: true }
-  | { valid: false; error: string };
-
-/**
- * Validate email format
- */
-export function isValidEmail(email: string): boolean {
-  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailRegex.test(email);
-}
-
-/**
- * Validate password length
- */
-export function isValidPassword(password: string, minLength: number = 8): boolean {
-  return password.length >= minLength;
-}
-
-/**
- * Validate login credentials
- */
-export function validateLogin(credentials: LoginCredentials): ValidationResult {
-  if (!credentials.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(credentials.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  if (!credentials.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate registration data
- */
-export function validateRegister(
-  data: RegisterData & { confirmPassword?: string },
-  requireName: boolean = false,
-  requirePasswordConfirm?: boolean,
-): ValidationResult {
-  if (!data.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(data.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  if (requireName && !data.name) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.nameRequired };
-  }
-  if (!data.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  if (!isValidPassword(data.password)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
-  }
-  if (requirePasswordConfirm && data.password !== data.confirmPassword) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate forgot-password request
- */
-export function validateForgotPassword(data: { email: string }): ValidationResult {
-  if (!data.email) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailRequired };
-  }
-  if (!isValidEmail(data.email)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.emailInvalid };
-  }
-  return { valid: true };
-}
-
-/**
- * Validate password reset confirmation
- */
-export function validateResetPassword(data: {
-  token: string;
-  password: string;
-  confirmPassword: string;
-}): ValidationResult {
-  if (!data.token) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.invalidResetToken };
-  }
-  if (!data.password) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordRequired };
-  }
-  if (!isValidPassword(data.password)) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordTooShort };
-  }
-  if (data.password !== data.confirmPassword) {
-    return { valid: false, error: AUTH_VALIDATION_KEYS.passwordsDoNotMatch };
-  }
-  return { valid: true };
-}
-
-/**
- * Get user display name
- *
- * Returns null when no usable identifier exists, letting the caller
- * decide on a localized fallback. Avoids hardcoded "Guest"/"User" strings.
- */
-export function getUserDisplayName(user: User | null): string | null {
-  if (!user) return null;
-  return user.name || user.email || null;
-}
-
-/**
- * Get user initials
- *
- * Returns null when no name is available, so the caller can decide
- * whether to render a placeholder or hide the avatar.
- */
-export function getUserInitials(user: User | null): string | null {
-  if (!user) return null;
-  const name = user.name || user.email || "";
-  if (!name) return null;
-  const parts = name.trim().split(" ");
-  if (parts.length >= 2 && parts[0] && parts[parts.length - 1]) {
-    return (parts[0][0] + parts[parts.length - 1][0]).toUpperCase();
-  }
-  return name.slice(0, 2).toUpperCase();
-}
-
-/**
- * Check if user has verified email
- */
-export function isEmailVerified(user: User | null): boolean {
-  return user?.emailVerified === true;
-}
-
-/**
- * Format user creation date
- *
- * Returns null when the user has no createdAt; the caller decides
- * whether to display "—" or hide the field.
- */
-export function formatUserCreatedAt(
-  user: User | null,
-  locale: string = "en-US",
-): string | null {
-  if (!user?.createdAt) return null;
-  return new Date(user.createdAt).toLocaleDateString(locale, {
-    year: "numeric",
-    month: "long",
-    day: "numeric",
-  });
-}
-
-/**
- * Mask email for privacy (e.g., u***@example.com)
- *
- * Returns null when the email is invalid so the caller can show
- * a "—" placeholder rather than the raw input.
- */
-export function maskEmail(email: string): string | null {
-  const [local, domain] = email.split("@");
-  if (!local || !domain) return null;
-  const maskedLocal = local[0] + "***";
-  return `${maskedLocal}@${domain}`;
-}
-
-/**
- * Password strength score (0-100)
- */
-export function calculatePasswordStrength(password: string): number {
-  let score = 0;
-
-  if (password.length >= 8) score += 25;
-  if (password.length >= 12) score += 25;
-
-  if (/[a-z]/.test(password)) score += 12.5;
-  if (/[A-Z]/.test(password)) score += 12.5;
-  if (/[0-9]/.test(password)) score += 12.5;
-  if (/[^a-zA-Z0-9]/.test(password)) score += 12.5;
-
-  return Math.min(score, 100);
-}
-
-/**
- * Password strength band. Numeric so the UI can map it to a label
- * via its own translation catalog.
- */
-export type PasswordStrengthBand = 'weak' | 'fair' | 'good' | 'strong';
-
-export function getPasswordStrengthBand(password: string): PasswordStrengthBand {
-  const score = calculatePasswordStrength(password);
-  if (score < 25) return 'weak';
-  if (score < 50) return 'fair';
-  if (score < 75) return 'good';
-  return 'strong';
-}
-
-/**
- * Sanitize user input for display
- */
-export function sanitizeInput(input: string, maxLength: number = 1000): string {
-  return input.trim().slice(0, maxLength);
-}

package/src/domains/auth/utils/i18nKeys.ts

@@ -1,109 +0,0 @@
-export const AUTH_KEYS = {
-  login: {
-    welcomeBack: 'auth.login.welcomeBack',
-    signInTo: 'auth.login.signInTo',
-    submit: 'auth.login.submit',
-    submitting: 'auth.login.submitting',
-    rememberMe: 'auth.login.rememberMe',
-    forgotPassword: 'auth.login.forgotPassword',
-    noAccount: 'auth.login.noAccount',
-    signUp: 'auth.login.signUp',
-    orContinueWith: 'auth.login.orContinueWith',
-  },
-
-  register: {
-    createAccount: 'auth.register.createAccount',
-    join: 'auth.register.join',
-    fullName: 'auth.register.fullName',
-    fullNamePlaceholder: 'auth.placeholders.fullName',
-    confirmPassword: 'auth.register.confirmPassword',
-    confirmPasswordPlaceholder: 'auth.placeholders.confirmPassword',
-    acceptTerms: 'auth.register.acceptTerms',
-    termsOfService: 'auth.register.termsOfService',
-    privacyPolicy: 'auth.register.privacyPolicy',
-    submit: 'auth.register.submit',
-    submitting: 'auth.register.submitting',
-    haveAccount: 'auth.register.haveAccount',
-    signIn: 'auth.register.signIn',
-    mustAcceptTerms: 'auth.register.mustAcceptTerms',
-    passwordsDoNotMatch: 'auth.register.passwordsDoNotMatch',
-  },
-
-  forgotPassword: {
-    title: 'auth.forgotPassword.title',
-    description: 'auth.forgotPassword.description',
-    submit: 'auth.forgotPassword.submit',
-    submitting: 'auth.forgotPassword.submitting',
-    backToSignIn: 'auth.forgotPassword.backToSignIn',
-    successTitle: 'auth.forgotPassword.successTitle',
-    successMessage: 'auth.forgotPassword.successMessage',
-    sentTo: 'auth.forgotPassword.sentTo',
-    checkEmail: 'auth.forgotPassword.checkEmail',
-    step1: 'auth.forgotPassword.steps.step1',
-    step2: 'auth.forgotPassword.steps.step2',
-    step3: 'auth.forgotPassword.steps.step3',
-  },
-
-  resetPassword: {
-    title: 'auth.resetPassword.title',
-    description: 'auth.resetPassword.description',
-    newPassword: 'auth.resetPassword.newPassword',
-    confirmNewPassword: 'auth.resetPassword.confirmNewPassword',
-    submit: 'auth.resetPassword.submit',
-    submitting: 'auth.resetPassword.submitting',
-    successTitle: 'auth.resetPassword.successTitle',
-    successMessage: 'auth.resetPassword.successMessage',
-    goToSignIn: 'auth.resetPassword.goToSignIn',
-  },
-
-  fields: {
-    email: 'auth.fields.email',
-    password: 'auth.fields.password',
-    name: 'auth.fields.name',
-  },
-
-  placeholders: {
-    emailExample: 'auth.placeholders.emailExample',
-    password: 'auth.placeholders.password',
-    fullName: 'auth.placeholders.fullName',
-  },
-
-  errors: {
-    invalidCredentials: 'auth.errors.invalidCredentials',
-    loginFailed: 'auth.errors.loginFailed',
-    noAuthProvider: 'auth.errors.noAuthProvider',
-    registrationFailed: 'auth.errors.registrationFailed',
-    emailRequired: 'auth.errors.emailRequired',
-    emailInvalid: 'auth.errors.emailInvalid',
-    passwordRequired: 'auth.errors.passwordRequired',
-    passwordTooShort: 'auth.errors.passwordTooShort',
-    passwordsDoNotMatch: 'auth.errors.passwordsDoNotMatch',
-    sendResetFailed: 'auth.errors.sendResetFailed',
-    resetFailed: 'auth.errors.resetFailed',
-  },
-
-  passwordStrength: {
-    weak: 'auth.passwordStrength.weak',
-    fair: 'auth.passwordStrength.fair',
-    good: 'auth.passwordStrength.good',
-    strong: 'auth.passwordStrength.strong',
-  },
-
-  social: {
-    continueWithGoogle: 'auth.social.continueWithGoogle',
-    continueWithApple: 'auth.social.continueWithApple',
-  },
-
-  layout: {
-    backToHome: 'auth.layout.backToHome',
-    orContinueWith: 'auth.layout.orContinueWith',
-    allRightsReserved: 'auth.layout.allRightsReserved',
-  },
-
-  a11y: {
-    showPassword: 'auth.a11y.showPassword',
-    hidePassword: 'auth.a11y.hidePassword',
-  },
-} as const;
-
-export type AuthI18nKey = string;

package/src/domains/auth/utils/index.ts

@@ -1,29 +0,0 @@
-/**
- * Auth Utilities
- *
- * Export all auth utilities
- */
-
-export {
-  isValidEmail,
-  isValidPassword,
-  validateLogin,
-  validateRegister,
-  validateForgotPassword,
-  validateResetPassword,
-  getUserDisplayName,
-  getUserInitials,
-  isEmailVerified,
-  formatUserCreatedAt,
-  maskEmail,
-  generateResetToken,
-  calculatePasswordStrength,
-  getPasswordStrengthBand,
-  sanitizeInput,
-  type ValidationResult,
-  type PasswordStrengthBand,
-} from "./auth";
-
-export { AUTH_KEYS } from "./i18nKeys";
-export { AUTH_VALIDATION_KEYS } from "./validationKeys";
-export type { AuthValidationKey } from "./validationKeys";

package/src/domains/auth/utils/secureToken.ts

@@ -1,33 +0,0 @@
-/**
- * Auth Utilities - Secure Token
- *
- * Cryptographically secure token generation utilities
- */
-
-/**
- * Generate a cryptographically secure random token.
- *
- * Requires the Web Crypto API (`crypto.getRandomValues`), available in
- * all modern browsers, Node.js >= 19 (and >= 15 via `globalThis.crypto`),
- * and React Native with a crypto polyfill. Throws instead of silently
- * degrading to an insecure PRNG — predictable tokens are worse than
- * a loud failure.
- *
- * @param length - Token length in bytes (default: 32)
- * @returns Hex-encoded random token
- * @throws Error when no CSPRNG is available in the runtime
- */
-export function generateResetToken(length: number = 32): string {
-  if (typeof crypto === 'undefined' || typeof crypto.getRandomValues !== 'function') {
-    throw new Error(
-      'generateResetToken: no cryptographic random source available in this runtime ' +
-        '(requires crypto.getRandomValues — Web Crypto, Node >= 19, or a polyfill)',
-    );
-  }
-
-  const byteLength = Math.max(1, Math.floor(length));
-  const bytes = new Uint8Array(byteLength);
-  crypto.getRandomValues(bytes);
-
-  return Array.from(bytes, (b) => b.toString(16).padStart(2, '0')).join('');
-}

package/src/domains/auth/utils/validationKeys.ts

@@ -1,23 +0,0 @@
-/**
- * Auth Validation Error Keys
- *
- * Stable i18n keys for validation errors. The auth UI maps these to
- * localized messages via the consumer's translation system.
- *
- * Why keys instead of literal strings:
- *   - No hardcoded user-facing strings in source code
- *   - Centralized catalog: easier to audit and translate
- *   - Validators stay pure and testable
- */
-
-export const AUTH_VALIDATION_KEYS = {
-  emailRequired: 'auth.validation.emailRequired',
-  emailInvalid: 'auth.validation.emailInvalid',
-  passwordRequired: 'auth.validation.passwordRequired',
-  passwordTooShort: 'auth.validation.passwordTooShort',
-  passwordsDoNotMatch: 'auth.validation.passwordsDoNotMatch',
-  nameRequired: 'auth.validation.nameRequired',
-  invalidResetToken: 'auth.validation.invalidResetToken',
-} as const;
-
-export type AuthValidationKey = (typeof AUTH_VALIDATION_KEYS)[keyof typeof AUTH_VALIDATION_KEYS];

package/src/domains/session/DemoLogin.tsx

@@ -1,42 +0,0 @@
-import { UserRound } from "lucide-react";
-import { Button } from "@umituz/web-design-system/atoms";
-import { useT } from "@umituz/web-localization/react";
-import { SESSION_KEYS } from "./utils/i18nKeys";
-
-export interface DemoLoginProps {
-  onDemo: (userId: string) => void | Promise<void>;
-  userId: string;
-  label?: string;
-  variant?: "default" | "outline" | "ghost";
-  size?: "default" | "sm";
-  disabled?: boolean;
-  className?: string;
-}
-
-export const DemoLogin = ({
-  onDemo,
-  userId,
-  label,
-  variant = "outline",
-  size = "default",
-  disabled = false,
-  className,
-}: DemoLoginProps) => {
-  const t = useT();
-
-  return (
-    <Button
-      type="button"
-      variant={variant}
-      size={size}
-      disabled={disabled}
-      className={className}
-      onClick={() => void onDemo(userId)}
-    >
-      <UserRound aria-hidden="true" />
-      {label ?? t(SESSION_KEYS.demoLogin.action)}
-    </Button>
-  );
-};
-
-export default DemoLogin;

package/src/domains/session/OrgSwitcher.tsx

@@ -1,102 +0,0 @@
-import { useState } from "react";
-import { Building2, Check, ChevronDown } from "lucide-react";
-import { cn } from "@umituz/web-design-system/utils/cn";
-import { useT } from "@umituz/web-localization/react";
-import { SESSION_KEYS } from "./utils/i18nKeys";
-import type { Tenant } from "./types";
-
-export interface OrgSwitcherProps {
-  tenants: Tenant[];
-  activeTenantId?: string | null;
-  onSwitch: (tenantId: string) => void;
-  disabled?: boolean;
-  className?: string;
-}
-
-const initialsOf = (tenant: Tenant): string =>
-  tenant.initials ??
-  tenant.name
-    .split(/\s+/)
-    .slice(0, 2)
-    .map((word) => word.charAt(0).toUpperCase())
-    .join("");
-
-export const OrgSwitcher = ({
-  tenants,
-  activeTenantId,
-  onSwitch,
-  disabled = false,
-  className,
-}: OrgSwitcherProps) => {
-  const t = useT();
-  const [open, setOpen] = useState(false);
-
-  if (tenants.length === 0) return null;
-
-  const active = tenants.find((tenant) => tenant.id === activeTenantId) ?? tenants[0];
-
-  return (
-    <div className={cn("udb-header__anchor", className)}>
-      <button
-        type="button"
-        className="udb-profile-btn"
-        disabled={disabled}
-        aria-haspopup="menu"
-        aria-expanded={open}
-        aria-label={t(SESSION_KEYS.orgSwitcher.label)}
-        onClick={() => setOpen((prev) => !prev)}
-      >
-        <span className="udb-avatar">{initialsOf(active)}</span>
-        <span className="udb-org">
-          <span className="udb-org__name">{active.name}</span>
-          {active.plan && <span className="udb-org__meta">{active.plan}</span>}
-        </span>
-        <ChevronDown
-          className={cn(
-            "udb-profile-btn__chevron",
-            open && "udb-profile-btn__chevron--open",
-          )}
-          aria-hidden="true"
-        />
-      </button>
-
-      {open && (
-        <>
-          <button
-            type="button"
-            className="udb-overlay"
-            aria-label="close tenant menu"
-            tabIndex={-1}
-            onClick={() => setOpen(false)}
-          />
-          <div className="udb-menu udb-org-menu" role="menu">
-            {tenants.map((tenant) => {
-              const isActive = tenant.id === active.id;
-              return (
-                <button
-                  key={tenant.id}
-                  type="button"
-                  role="menuitem"
-                  className={cn(
-                    "udb-menu__item",
-                    isActive && "udb-menu__item--active",
-                  )}
-                  onClick={() => {
-                    onSwitch(tenant.id);
-                    setOpen(false);
-                  }}
-                >
-                  <Building2 className="udb-menu__item-icon" aria-hidden="true" />
-                  <span className="udb-org-menu__label">{tenant.name}</span>
-                  {isActive && <Check className="udb-org-menu__check" aria-hidden="true" />}
-                </button>
-              );
-            })}
-          </div>
-        </>
-      )}
-    </div>
-  );
-};
-
-export default OrgSwitcher;