@goplusvn/core 0.1.0 → 0.1.1

package/src/utils/index.ts

@@ -0,0 +1,906 @@
+// @goerp/core/utils
+// Utility functions for GoERP platform
+
+import { clsx } from "clsx";
+import type { ClassValue } from "clsx";
+import { twMerge } from "tailwind-merge";
+
+// Import types from core/types
+import type { LocaleType, FormatStyleType } from "../types";
+
+// ============================================================================
+// Class Names
+// ============================================================================
+
+/**
+ * Merge Tailwind CSS classes with clsx
+ */
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+// ============================================================================
+// String Utilities
+// ============================================================================
+
+/**
+ * Get initials from full name
+ */
+export function getInitials(fullName: string): string {
+  if (fullName.length === 0) return "";
+  const names = fullName.split(" ");
+  const initials = names.map((name) => name.charAt(0).toUpperCase()).join("");
+  return initials;
+}
+
+/**
+ * Slugify string
+ */
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/(^-|-$)/g, "");
+}
+
+/**
+ * Convert camelCase to Title Case
+ */
+export function camelCaseToTitleCase(camelCaseStr: string): string {
+  return camelCaseStr
+    .replace(/([A-Z])/g, " $1")
+    .replace(/^./, (char) => char.toUpperCase());
+}
+
+/**
+ * Convert Title Case to camelCase
+ */
+export function titleCaseToCamelCase(titleCaseStr: string): string {
+  return titleCaseStr
+    .toLowerCase()
+    .replace(/[-_\s]+(.)/g, (_, char) => char.toUpperCase())
+    .replace(/[-_]/g, "");
+}
+
+// ============================================================================
+// Number Utilities
+// ============================================================================
+
+export const isEven = (num: number) => num % 2 === 0;
+export const isNonNegative = (num: number) => num >= 0;
+
+/**
+ * Đọc số tiền thành chữ tiếng Việt
+ * Dùng chung cho tất cả các phiếu in (hợp đồng, phiếu thu, phiếu chi, phiếu nhập/xuất kho, v.v.)
+ * @param amount - Số tiền (VND)
+ * @returns Chuỗi đọc bằng chữ, VD: "Bảy mươi hai triệu một trăm năm mươi chín nghìn tám trăm hai mươi đồng"
+ */
+export function readMoney(amount: number): string {
+  if (!Number.isFinite(amount)) return "Không đồng"
+
+  const isNegative = amount < 0
+
+  // Bỏ phần thập phân - VND không có đơn vị lẻ
+  amount = Math.floor(Math.abs(amount))
+
+  if (amount === 0) return "Không đồng"
+
+  const unit = ["", "nghìn", "triệu", "tỷ", "nghìn tỷ", "triệu tỷ"]
+  const digit = [
+    "không",
+    "một",
+    "hai",
+    "ba",
+    "bốn",
+    "năm",
+    "sáu",
+    "bảy",
+    "tám",
+    "chín",
+  ]
+
+  let str = amount.toString()
+  const groups: string[] = []
+  while (str.length > 0) {
+    groups.push(str.slice(-3))
+    str = str.slice(0, -3)
+  }
+
+  let result = ""
+  for (let i = 0; i < groups.length; i++) {
+    const group = groups[i]
+    if (group === "000") continue
+
+    const [a, b, c] = group.padStart(3, "0").split("").map(Number)
+    let groupResult = ""
+
+    const hasHundreds = a !== 0 || groups.length > 1
+
+    if (hasHundreds) {
+      groupResult += `${digit[a]} trăm `
+    }
+
+    if (b === 0 && c !== 0) {
+      if (hasHundreds) groupResult += "lẻ "
+    } else if (b === 1) {
+      groupResult += "mười "
+    } else if (b > 1) {
+      groupResult += `${digit[b]} mươi `
+    }
+
+    if (c === 1 && b > 1) {
+      groupResult += "mốt "
+    } else if (c === 5 && b > 0) {
+      groupResult += "lăm "
+    } else if (c !== 0) {
+      groupResult += `${digit[c]} `
+    }
+
+    if (i === groups.length - 1 && a === 0) {
+      groupResult = groupResult.replace("không trăm ", "")
+      if (b === 0) groupResult = groupResult.replace("lẻ ", "")
+    }
+
+    if (groupResult.trim() !== "") {
+      result = `${groupResult.trim()} ${unit[i]} ${result}`
+    }
+  }
+
+  result = result.trim() + " đồng"
+
+  if (isNegative) {
+    return "Âm " + result
+  }
+
+  return result.charAt(0).toUpperCase() + result.slice(1)
+}
+
+/**
+ * Format currency with locale
+ */
+export function formatCurrency(
+  value: number,
+  locales: LocaleType = "vi",
+  currency: string = "VND",
+): string {
+  return new Intl.NumberFormat(locales === "vi" ? "vi-VN" : locales, {
+    style: "decimal",
+    maximumFractionDigits: 0,
+  }).format(value);
+}
+
+/**
+ * Format number with locale
+ */
+export function formatNumber(
+  value: number,
+  options?: {
+    locale?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+  },
+): string {
+  const {
+    locale = "vi-VN",
+    minimumFractionDigits = 0,
+    maximumFractionDigits = 2,
+  } = options || {};
+
+  return new Intl.NumberFormat(locale, {
+    minimumFractionDigits,
+    maximumFractionDigits,
+  }).format(value);
+}
+
+/**
+ * Format percent
+ */
+export function formatPercent(
+  value: number,
+  locales: LocaleType = "vi",
+): string {
+  return new Intl.NumberFormat(locales === "vi" ? "vi-VN" : locales, {
+    style: "percent",
+    maximumFractionDigits: 0,
+  }).format(value);
+}
+
+/**
+ * Format number to compact (e.g., 1K, 1M)
+ */
+export function formatNumberToCompact(
+  value: number,
+  locales: LocaleType = "vi",
+): string {
+  return new Intl.NumberFormat(locales === "vi" ? "vi-VN" : locales, {
+    notation: "compact",
+    compactDisplay: "short",
+  }).format(value);
+}
+
+/**
+ * Format file size
+ */
+export function formatFileSize(bytes: number, decimals: number = 2): string {
+  if (bytes === 0) return "0 Bytes";
+
+  const k = 1000;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+}
+
+/**
+ * Format unread count
+ */
+export function formatUnreadCount(unreadCount: number): string | number {
+  return unreadCount >= 100 ? "+99" : unreadCount;
+}
+
+// ============================================================================
+// Date Utilities
+// ============================================================================
+
+/**
+ * Format date with Vietnamese locale (Asia/Ho_Chi_Minh timezone)
+ */
+export function formatDate(
+  date: Date | string,
+  options?: {
+    locale?: string;
+    format?: "short" | "medium" | "long" | "full";
+  },
+): string {
+  const { locale = "vi-VN", format = "medium" } = options || {};
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+
+  const formatOptions: Record<string, Intl.DateTimeFormatOptions> = {
+    short: { day: "2-digit", month: "2-digit", year: "numeric", timeZone: "Asia/Ho_Chi_Minh" },
+    medium: { day: "2-digit", month: "short", year: "numeric", timeZone: "Asia/Ho_Chi_Minh" },
+    long: { day: "numeric", month: "long", year: "numeric", timeZone: "Asia/Ho_Chi_Minh" },
+    full: { weekday: "long", day: "numeric", month: "long", year: "numeric", timeZone: "Asia/Ho_Chi_Minh" },
+  };
+
+  return new Intl.DateTimeFormat(locale, formatOptions[format]).format(dateObj);
+}
+
+/**
+ * Format datetime with Vietnamese locale (Asia/Ho_Chi_Minh timezone)
+ */
+export function formatDateTime(
+  date: Date | string,
+  options?: {
+    locale?: string;
+  },
+): string {
+  const { locale = "vi-VN" } = options || {};
+  const dateObj = typeof date === "string" ? new Date(date) : date;
+
+  return new Intl.DateTimeFormat(locale, {
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(dateObj);
+}
+
+/**
+ * Format relative date (Today, Yesterday, or date) - Asia/Ho_Chi_Minh timezone
+ */
+export function formatRelativeDate(value?: string | number | Date): string {
+  if (!value) return "No Date";
+
+  const date = new Date(value);
+  const today = new Date();
+  const yesterday = new Date();
+  yesterday.setDate(today.getDate() - 1);
+
+  // Compare dates in Vietnam timezone
+  const vnDateStr = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Ho_Chi_Minh", year: "numeric", month: "2-digit", day: "2-digit" }).format(date);
+  const vnTodayStr = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Ho_Chi_Minh", year: "numeric", month: "2-digit", day: "2-digit" }).format(today);
+  const vnYesterdayStr = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Ho_Chi_Minh", year: "numeric", month: "2-digit", day: "2-digit" }).format(yesterday);
+
+  if (vnDateStr === vnTodayStr) return "Today";
+  if (vnDateStr === vnYesterdayStr) return "Yesterday";
+
+  return formatDate(date);
+}
+
+/**
+ * Check if date is before today (Asia/Ho_Chi_Minh timezone)
+ */
+export function isBeforeToday(date: Date): boolean {
+  const vnTodayStr = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Ho_Chi_Minh", year: "numeric", month: "2-digit", day: "2-digit" }).format(new Date());
+  const vnDateStr = new Intl.DateTimeFormat("en-CA", { timeZone: "Asia/Ho_Chi_Minh", year: "numeric", month: "2-digit", day: "2-digit" }).format(date);
+  return vnDateStr < vnTodayStr;
+}
+
+// ============================================================================
+// Path Utilities
+// ============================================================================
+
+/**
+ * Ensure path has prefix
+ */
+export function ensureWithPrefix(value: string, prefix: string): string {
+  return value.startsWith(prefix) ? value : `${prefix}${value}`;
+}
+
+/**
+ * Ensure path has suffix
+ */
+export function ensureWithSuffix(value: string, suffix: string): string {
+  return value.endsWith(suffix) ? value : `${value}${suffix}`;
+}
+
+/**
+ * Ensure path without prefix
+ */
+export function ensureWithoutPrefix(value: string, prefix: string): string {
+  return value.startsWith(prefix) ? value.slice(prefix.length) : value;
+}
+
+/**
+ * Ensure path without suffix
+ */
+export function ensureWithoutSuffix(value: string, suffix: string): string {
+  return value.endsWith(suffix) ? value.slice(0, -suffix.length) : value;
+}
+
+/**
+ * Check if pathname is active
+ */
+export function isActivePathname(
+  basePathname: string,
+  currentPathname: string,
+  exactMatch: boolean = false,
+): boolean {
+  if (typeof basePathname !== "string" || typeof currentPathname !== "string") {
+    throw new Error("Both basePathname and currentPathname must be strings");
+  }
+
+  if (exactMatch) {
+    return basePathname === currentPathname;
+  }
+
+  return (
+    currentPathname.startsWith(basePathname) &&
+    (currentPathname.length === basePathname.length ||
+      currentPathname[basePathname.length] === "/")
+  );
+}
+
+// ============================================================================
+// General Utilities
+// ============================================================================
+
+/**
+ * Wait/sleep function
+ */
+export function wait(ms: number = 250): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Debounce function
+ */
+export function debounce<T extends (...args: unknown[]) => unknown>(
+  func: T,
+  wait: number,
+): (...args: Parameters<T>) => void {
+  let timeout: ReturnType<typeof setTimeout> | null = null;
+
+  return (...args: Parameters<T>) => {
+    if (timeout) {
+      clearTimeout(timeout);
+    }
+    timeout = setTimeout(() => func(...args), wait);
+  };
+}
+
+/**
+ * Deep clone object
+ */
+export function deepClone<T>(obj: T): T {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+/**
+ * Check if value is empty
+ */
+export function isEmpty(value: unknown): boolean {
+  if (value === null || value === undefined) return true;
+  if (typeof value === "string") return value.trim() === "";
+  if (Array.isArray(value)) return value.length === 0;
+  if (typeof value === "object") return Object.keys(value).length === 0;
+  return false;
+}
+
+/**
+ * Generate a random ID
+ */
+export function generateId(prefix?: string): string {
+  const id = Math.random().toString(36).substring(2, 11);
+  return prefix ? `${prefix}_${id}` : id;
+}
+
+/**
+ * Get dictionary value safely
+ */
+export function getDictionaryValue(
+  key: string,
+  section: Record<string, unknown>,
+  fallback?: string,
+): string {
+  const value = section[key];
+
+  if (typeof value !== "string") {
+    if (fallback !== undefined) {
+      return fallback;
+    }
+
+    const normalizedKey = key.replace(/[-_]/g, "");
+    const normalizedValue = section[normalizedKey];
+
+    if (typeof normalizedValue === "string") {
+      return normalizedValue;
+    }
+
+    return key;
+  }
+
+  return value;
+}
+
+/**
+ * Format overview card value based on style
+ */
+export function formatOverviewCardValue(
+  value: number,
+  formatStyle: FormatStyleType,
+): string | number {
+  switch (formatStyle) {
+    case "percent":
+      return formatPercent(value);
+    case "currency":
+      return formatCurrency(value);
+    default:
+      return value.toLocaleString("vi-VN", {
+        maximumFractionDigits: 0,
+      });
+  }
+}
+
+// ============================================================================
+// Additional Utilities (migrated from shared-utils)
+// ============================================================================
+
+/**
+ * Get credit card brand name from number
+ */
+export function getCreditCardBrandName(number: string): string {
+  const re = {
+    visa: /^4/,
+    mastercard: /^5[1-5]/,
+    amex: /^3[47]/,
+    discover: /^6(?:011|5)/,
+  };
+
+  for (const [type, regex] of Object.entries(re)) {
+    if (regex.test(number)) return type;
+  }
+  return "unknown";
+}
+
+/**
+ * Convert rem to pixels
+ */
+export function remToPx(rem: number): number {
+  if (typeof document === "undefined") return rem * 16;
+  const rootFontSize = parseFloat(
+    getComputedStyle(document.documentElement).fontSize,
+  );
+  return rem * rootFontSize;
+}
+
+/**
+ * Check if string is a valid URL
+ */
+export function isUrl(text: string): boolean {
+  try {
+    new URL(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Rating to percentage string
+ */
+export function ratingToPercentage(
+  rating: number,
+  maxRating: number,
+  fractionDigits: number = 0,
+): string {
+  const value = ((rating / maxRating) * 100).toFixed(fractionDigits);
+  return value + "%";
+}
+
+/**
+ * Ensure redirect pathname with query params
+ */
+export function ensureRedirectPathname(
+  basePathname: string,
+  redirectPathname: string,
+): string {
+  const searchParams = new URLSearchParams({
+    redirectTo: ensureWithoutSuffix(redirectPathname, "/"),
+  });
+
+  return ensureWithSuffix(basePathname, "?" + searchParams.toString());
+}
+
+/**
+ * Get discounted price
+ */
+export function getDiscountedPrice(
+  price: number,
+  discountRate: number,
+  isAnnual: boolean = false,
+): number {
+  if (isAnnual) {
+    const annualPrice = price * 12;
+    const discountedAnnualPrice = annualPrice * (1 - discountRate);
+    return discountedAnnualPrice / 12;
+  } else {
+    return price * (1 - discountRate);
+  }
+}
+
+/**
+ * Convert time string to Date
+ */
+export function timeToDate(timeString: string, baseDate = new Date()): Date {
+  if (!/^\d{2}:\d{2}$/.test(timeString)) {
+    throw new Error("Invalid time format. Use 'HH:mm'.");
+  }
+
+  const [hours, minutes] = timeString.split(":").map(Number);
+  const date = new Date(baseDate);
+
+  date.setHours(hours, minutes, 0, 0);
+
+  return date;
+}
+
+/**
+ * Format file type
+ */
+export function formatFileType(type: string): string {
+  return type.slice(0, type.lastIndexOf("/"));
+}
+
+/**
+ * Format date with time (Asia/Ho_Chi_Minh timezone)
+ */
+export function formatDateWithTime(value: string | number | Date): string {
+  const date = new Date(value);
+  return new Intl.DateTimeFormat("vi-VN", {
+    day: "2-digit",
+    month: "2-digit",
+    year: "numeric",
+    hour: "2-digit",
+    minute: "2-digit",
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(date);
+}
+
+/**
+ * Format date short (MMM dd) - Asia/Ho_Chi_Minh timezone
+ */
+export function formatDateShort(value: string | number | Date): string {
+  const date = new Date(value);
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "2-digit",
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(date);
+}
+
+/**
+ * Format time (Asia/Ho_Chi_Minh timezone)
+ */
+export function formatTime(value: string | number | Date): string {
+  const date = new Date(value);
+  return new Intl.DateTimeFormat("en-US", {
+    hour: "numeric",
+    minute: "2-digit",
+    hour12: true,
+    timeZone: "Asia/Ho_Chi_Minh",
+  }).format(date);
+}
+
+/**
+ * Format duration from milliseconds
+ */
+export function formatDuration(value: string | number | Date): string {
+  const numberValue = Number(value);
+  const isNegative = numberValue < 0;
+  const absoluteValue = Math.abs(numberValue);
+
+  const hours = Math.floor(absoluteValue / 3600000);
+  const minutes = Math.floor((absoluteValue % 3600000) / 60000);
+  const seconds = Math.floor((absoluteValue % 60000) / 1000);
+
+  const parts = [];
+  if (hours) parts.push(`${hours}h`);
+  if (minutes) parts.push(`${minutes}m`);
+  if (seconds) parts.push(`${seconds}s`);
+
+  const formattedDuration = parts.join(" ") || "0s";
+
+  return isNegative ? `-${formattedDuration}` : formattedDuration;
+}
+
+/**
+ * Format distance to now
+ */
+export function formatDistance(value: string | number | Date): string {
+  const date = new Date(value);
+  const now = new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 60000);
+  const diffHours = Math.floor(diffMs / 3600000);
+  const diffDays = Math.floor(diffMs / 86400000);
+
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins} mins ago`;
+  if (diffHours < 24) return `${diffHours} hrs ago`;
+  if (diffDays < 30) return `${diffDays} days ago`;
+  if (diffDays < 365) return `${Math.floor(diffDays / 30)} months ago`;
+  return `${Math.floor(diffDays / 365)} years ago`;
+}
+
+// Re-export status constants from configs
+export {
+  STATUS_COLORS,
+  STATUS_ACTIVE,
+  STATUS_INACTIVE,
+  STATUS_OPTIONS,
+  STATUS_VALUES,
+  booleanToStatus,
+  statusToBoolean,
+} from "../configs/status";
+
+// ============================================================================
+// Localization Utilities
+// ============================================================================
+
+const LOCALE_LIST = ["vi", "en"];
+
+export function isPathnameMissingLocale(pathname: string) {
+  return !LOCALE_LIST.some((locale) => pathname.startsWith(`/${locale}`));
+}
+
+export function getLocaleFromPathname(pathname: string) {
+  return LOCALE_LIST.find((locale) => pathname.startsWith(`/${locale}`));
+}
+
+export function ensureLocalizedPathname(pathname: string, locale: string) {
+  if (!pathname || !locale)
+    throw new Error("Pathname or Locale cannot be empty");
+  return isPathnameMissingLocale(pathname)
+    ? `${ensureWithPrefix(locale, "/")}${ensureWithPrefix(pathname, "/")}`
+    : pathname;
+}
+
+export function relocalizePathname(pathname: string, locale: string) {
+  if (!pathname || !locale)
+    throw new Error("Pathname or Locale cannot be empty");
+  const segments = pathname.split("/");
+  segments[1] = locale;
+  return segments.join("/");
+}
+
+// ============================================================================
+// Logger
+// ============================================================================
+
+type LogLevel = "info" | "warn" | "error" | "debug";
+
+interface LogEntry {
+  timestamp: string;
+  level: LogLevel;
+  message: string;
+  context?: Record<string, unknown>;
+  error?: Error | unknown;
+}
+
+class Logger {
+  private log(
+    level: LogLevel,
+    message: string,
+    context?: Record<string, unknown>,
+    error?: unknown,
+  ) {
+    const entry: LogEntry = {
+      timestamp: new Date().toISOString(),
+      level,
+      message,
+      context,
+    };
+
+    if (error instanceof Error) {
+      entry.error = {
+        name: error.name,
+        message: error.message,
+        stack: error.stack,
+      };
+    } else if (error) {
+      entry.error = error;
+    }
+
+    const logString = JSON.stringify(entry);
+    switch (level) {
+      case "error":
+        console.error(logString);
+        break;
+      case "warn":
+        console.warn(logString);
+        break;
+      case "debug":
+        if (process.env.NODE_ENV === "development") console.debug(logString);
+        break;
+      default:
+        console.log(logString);
+    }
+  }
+
+  info(message: string, context?: Record<string, unknown>) {
+    this.log("info", message, context);
+  }
+  warn(message: string, context?: Record<string, unknown>) {
+    this.log("warn", message, context);
+  }
+  error(message: string, error?: unknown, context?: Record<string, unknown>) {
+    this.log("error", message, context, error);
+  }
+  debug(message: string, context?: Record<string, unknown>) {
+    this.log("debug", message, context);
+  }
+}
+
+export const logger = new Logger();
+
+// ============================================================================
+// Tab Navigation Utilities
+// ============================================================================
+
+import type {
+  NavigationType,
+  NavigationNestedItemWithHrefType,
+  NavigationNestedItemWithItemsType,
+  DynamicIconNameType,
+} from "../types";
+
+export function shouldExcludeFromTabs(pathname: string): boolean {
+  const excludePatterns = [
+    "/sign-in",
+    "/sign-out",
+    "/forgot-password",
+    "/new-password",
+    "/verify-email",
+    "/register",
+    "/unauthorized",
+    "/not-found",
+    "/maintenance",
+    "/coming-soon",
+  ];
+  if (
+    pathname.includes("/ui/") ||
+    pathname.includes("/colors") ||
+    pathname.includes("/typography")
+  )
+    return true;
+  return excludePatterns.some((pattern) => pathname.includes(pattern));
+}
+
+export function normalizePathname(pathname: string): string {
+  return pathname.replace(/^\/[a-z]{2}(\/|$)/, "/") || "/";
+}
+
+function formatSegmentLabel(segment: string): string {
+  return segment
+    .replace(/[-_]+/g, " ")
+    .replace(/\b\w/g, (char) => char.toUpperCase());
+}
+
+export function findRouteTitle(
+  pathname: string,
+  navigations: NavigationType[],
+): string | null {
+  const result = findRouteInfo(pathname, navigations);
+  return result?.title || null;
+}
+
+export function findRouteIcon(
+  pathname: string,
+  navigations: NavigationType[],
+): DynamicIconNameType | null {
+  const result = findRouteInfo(pathname, navigations);
+  return (result?.iconName as DynamicIconNameType) || null;
+}
+
+interface RouteInfo {
+  title: string;
+  iconName?: DynamicIconNameType;
+}
+
+function findRouteInfo(
+  pathname: string,
+  navigations: NavigationType[],
+): RouteInfo | null {
+  const normalizedPath = normalizePathname(pathname);
+  let exactMatch: RouteInfo | null = null;
+  const prefixMatches: Array<{ itemPath: string; routeInfo: RouteInfo }> = [];
+
+  function searchItems(
+    items:
+      | NavigationType["items"]
+      | Array<
+          NavigationNestedItemWithHrefType | NavigationNestedItemWithItemsType
+        >
+      | undefined,
+  ): void {
+    if (!items) return;
+    for (const item of items) {
+      if ("href" in item && item.href) {
+        const itemPath = normalizePathname(item.href);
+        if (normalizedPath === itemPath) {
+          exactMatch = {
+            title: item.title,
+            iconName:
+              "iconName" in item
+                ? (item.iconName as DynamicIconNameType | undefined)
+                : undefined,
+          };
+        } else if (normalizedPath.startsWith(itemPath + "/")) {
+          prefixMatches.push({
+            itemPath,
+            routeInfo: {
+              title: item.title,
+              iconName:
+                "iconName" in item
+                  ? (item.iconName as DynamicIconNameType | undefined)
+                  : undefined,
+            },
+          });
+        }
+      }
+      if ("items" in item && item.items) searchItems(item.items);
+    }
+  }
+
+  for (const nav of navigations) {
+    searchItems(nav.items);
+    if (exactMatch) return exactMatch;
+  }
+
+  if (prefixMatches.length > 0) {
+    prefixMatches.sort((a, b) => b.itemPath.length - a.itemPath.length);
+    return prefixMatches[0].routeInfo;
+  }
+
+  const segments = normalizedPath.split("/").filter(Boolean);
+  return segments.length > 0
+    ? { title: formatSegmentLabel(segments[segments.length - 1]) }
+    : { title: "Home" };
+}