@umituz/react-native-design-system 2.6.114 → 2.6.116

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-design-system",
-  "version": "2.6.114",
-  "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID and image utilities",
+  "version": "2.6.116",
+  "description": "Universal design system for React Native apps - Consolidated package with atoms, molecules, organisms, theme, typography, responsive, safe area, exception, infinite scroll, UUID, image and timezone utilities",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "exports": {
@@ -20,6 +20,7 @@
     "./safe-area": "./src/safe-area/index.ts",
     "./device": "./src/device/index.ts",
     "./image": "./src/image/index.ts",
+    "./timezone": "./src/timezone/index.ts",
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -42,7 +43,8 @@
     "typography",
     "responsive",
     "safe-area",
-    "image"
+    "image",
+    "timezone"
   ],
   "author": "Ümit UZ <umit@umituz.com>",
   "license": "MIT",

package/src/exports/timezone.ts

@@ -0,0 +1,7 @@
+/**
+ * Timezone Exports
+ *
+ * Timezone utilities and hooks for React Native
+ */
+
+export * from '../timezone';

package/src/index.ts

@@ -72,6 +72,11 @@ export * from './exports/infinite-scroll';
 // =============================================================================
 export * from './exports/uuid';
 
+// =============================================================================
+// TIMEZONE EXPORTS
+// =============================================================================
+export * from './exports/timezone';
+
 // =============================================================================
 // VARIANT UTILITIES
 // =============================================================================

package/src/timezone/domain/entities/Timezone.ts

@@ -0,0 +1,227 @@
+/**
+ * Timezone Domain Entities
+ *
+ * Core timezone types and interfaces for device timezone detection
+ * and date/time manipulation
+ *
+ * Features:
+ * - Auto-detects device timezone
+ * - Locale-aware date/time formatting
+ * - Calendar utilities
+ * - Date manipulation helpers
+ *
+ * Zero external dependencies - uses native Intl API
+ */
+
+/**
+ * Timezone information from device
+ */
+export interface TimezoneInfo {
+  /** IANA timezone identifier (e.g., "America/New_York", "Europe/Istanbul") */
+  timezone: string;
+
+  /** UTC offset in minutes (negative for west, positive for east) */
+  offset: number;
+
+  /** Human-readable timezone display name */
+  displayName: string;
+}
+
+/**
+ * Calendar day representation
+ * Generic structure - can be extended by apps for app-specific data
+ */
+export interface CalendarDay {
+  /** Date object for this day */
+  date: Date;
+
+  /** Day of month (1-31) */
+  day: number;
+
+  /** Day of week (0 = Sunday, 6 = Saturday) */
+  dayOfWeek: number;
+
+  /** Month (0-11, 0 = January) */
+  month: number;
+
+  /** Year (e.g., 2024) */
+  year: number;
+
+  /** Whether this day is in the current month */
+  isCurrentMonth: boolean;
+
+  /** Whether this day is today */
+  isToday: boolean;
+
+  /** ISO date string (YYYY-MM-DD) */
+  isoDate: string;
+}
+
+/**
+ * Timezone Service Interface
+ * Defines contract for timezone operations
+ */
+export interface ITimezoneService {
+  /** Get current device timezone (IANA identifier) */
+  getCurrentTimezone(): string;
+
+  /** Get timezone offset in minutes */
+  getTimezoneOffset(): number;
+
+  /** Get complete timezone information */
+  getTimezoneInfo(): TimezoneInfo;
+
+  /** Format date with locale support */
+  formatDate(
+    date: Date | string | number,
+    locale?: string,
+    options?: Intl.DateTimeFormatOptions,
+  ): string;
+
+  /** Format time with locale support */
+  formatTime(
+    date: Date | string | number,
+    locale?: string,
+    options?: Intl.DateTimeFormatOptions,
+  ): string;
+
+  /** Get calendar days for a month */
+  getCalendarDays(year: number, month: number): CalendarDay[];
+
+  /** Check if date is today */
+  isToday(date: Date | string | number): boolean;
+
+  /** Check if two dates are the same day */
+  isSameDay(date1: Date | string | number, date2: Date | string | number): boolean;
+
+  /** Add days to a date */
+  addDays(date: Date | string | number, days: number): Date;
+
+  /** Get start of day (00:00:00) */
+  startOfDay(date: Date | string | number): Date;
+
+  /** Get end of day (23:59:59.999) */
+  endOfDay(date: Date | string | number): Date;
+
+  /** Format date to ISO string (YYYY-MM-DD) */
+  formatDateToString(date: Date | string | number): string;
+
+  /** Format to display date string (DD.MM.YYYY) */
+  formatToDisplayDate(date: Date | string | number): string;
+
+  /** Format to display date time string (DD.MM.YYYY HH:mm) */
+  formatToDisplayDateTime(date: Date | string | number): string;
+
+  /** Get current date as ISO string (YYYY-MM-DDTHH:mm:ss.sssZ) */
+  getCurrentISOString(): string;
+
+  /** Get current date object */
+  getNow(): Date;
+
+  /** Parse input to Date object */
+  parse(date: Date | string | number): Date;
+
+  /** Check if date is in the future */
+  isFuture(date: Date | string | number): boolean;
+
+  /** Check if date is in the past */
+  isPast(date: Date | string | number): boolean;
+
+  /** Get days until a future date (returns 0 if past) */
+  getDaysUntil(date: Date | string | number): number;
+
+  /** Get difference in days between two dates */
+  getDifferenceInDays(date1: Date | string | number, date2: Date | string | number): number;
+
+  /** Format date to ISO datetime string (YYYY-MM-DDTHH:mm:ss.sssZ) */
+  formatToISOString(date: Date | string | number): string;
+
+  /** Get list of common timezones for selection */
+  getTimezones(): TimezoneInfo[];
+
+  /** Check if date is valid */
+  isValid(date: Date | string | number): boolean;
+
+  /** Calculate age from birth date */
+  getAge(birthDate: Date | string | number): number;
+
+  /** Check if date is between two dates (inclusive) */
+  isBetween(
+    date: Date | string | number,
+    start: Date | string | number,
+    end: Date | string | number,
+  ): boolean;
+
+  /** Get earliest date from array */
+  min(dates: Array<Date | string | number>): Date;
+
+  /** Get latest date from array */
+  max(dates: Array<Date | string | number>): Date;
+
+  /** Get ISO week number (1-53) */
+  getWeek(date: Date | string | number): number;
+
+  /** Get quarter (1-4) */
+  getQuarter(date: Date | string | number): number;
+
+  /** Get timezone offset for specific timezone in minutes */
+  getTimezoneOffsetFor(timezone: string, date?: Date | string | number): number;
+
+  /** Convert date from one timezone to another */
+  convertTimezone(
+    date: Date | string | number,
+    fromTimezone: string,
+    toTimezone: string,
+  ): Date;
+
+  /** Format duration in milliseconds to human readable string */
+  formatDuration(milliseconds: number): string;
+
+  /** Check if date is on weekend */
+  isWeekend(date: Date | string | number): boolean;
+
+  /** Add business days (skip weekends) */
+  addBusinessDays(date: Date | string | number, days: number): Date;
+
+  /** Check if date is first day of month */
+  isFirstDayOfMonth(date: Date | string | number): boolean;
+
+  /** Check if date is last day of month */
+  isLastDayOfMonth(date: Date | string | number): boolean;
+
+  /** Get number of days in month */
+  getDaysInMonth(date: Date | string | number): number;
+
+  /** Get array of dates in range */
+  getDateRange(
+    start: Date | string | number,
+    end: Date | string | number,
+  ): Date[];
+
+  /** Check if two date ranges overlap */
+  areRangesOverlapping(
+    start1: Date | string | number,
+    end1: Date | string | number,
+    start2: Date | string | number,
+    end2: Date | string | number,
+  ): boolean;
+
+  /** Clamp date to range */
+  clampDate(
+    date: Date | string | number,
+    min: Date | string | number,
+    max: Date | string | number,
+  ): Date;
+
+  /** Check if two dates are same hour */
+  areSameHour(date1: Date | string | number, date2: Date | string | number): boolean;
+
+  /** Check if two dates are same minute */
+  areSameMinute(date1: Date | string | number, date2: Date | string | number): boolean;
+
+  /** Get middle of day (12:00:00) */
+  getMiddleOfDay(date: Date | string | number): Date;
+
+  /** Get relative time from now ("5 minutes ago", "in 2 hours") */
+  fromNow(date: Date | string | number, locale?: string): string;
+}

package/src/timezone/index.ts

@@ -0,0 +1,31 @@
+/**
+ * @umituz/react-native-timezone - Public API
+ *
+ * Timezone detection and date/time utilities for React Native apps
+ *
+ * Usage:
+ *   import { useTimezone, timezoneService } from '@umituz/react-native-timezone';
+ */
+
+// =============================================================================
+// DOMAIN ENTITIES
+// =============================================================================
+
+export type {
+  TimezoneInfo,
+  CalendarDay,
+  ITimezoneService,
+} from './domain/entities/Timezone';
+
+// =============================================================================
+// INFRASTRUCTURE SERVICES
+// =============================================================================
+
+export { timezoneService, TimezoneService } from './infrastructure/services/TimezoneService';
+
+// =============================================================================
+// PRESENTATION HOOKS
+// =============================================================================
+
+export { useTimezone } from './presentation/hooks/useTimezone';
+export type { UseTimezoneReturn } from './presentation/hooks/useTimezone';

package/src/timezone/infrastructure/services/BusinessCalendarManager.ts

@@ -0,0 +1,70 @@
+/**
+ * BusinessCalendarManager
+ *
+ * Business date utilities for work days and month boundaries
+ * Handles weekend detection and business day calculations
+ */
+
+export class BusinessCalendarManager {
+  /**
+   * Check if date is on weekend (Saturday or Sunday)
+   */
+  isWeekend(date: Date | string | number): boolean {
+    const d = this.parse(date);
+    const day = d.getDay();
+    return day === 0 || day === 6;
+  }
+
+  /**
+   * Add business days (skips weekends)
+   * Positive days adds, negative days subtracts
+   */
+  addBusinessDays(date: Date | string | number, days: number): Date {
+    const result = this.parse(date);
+    const direction = days >= 0 ? 1 : -1;
+    let remainingDays = Math.abs(days);
+
+    while (remainingDays > 0) {
+      result.setDate(result.getDate() + direction);
+
+      if (!this.isWeekend(result)) {
+        remainingDays--;
+      }
+    }
+
+    return result;
+  }
+
+  /**
+   * Check if date is first day of month
+   */
+  isFirstDayOfMonth(date: Date | string | number): boolean {
+    const d = this.parse(date);
+    return d.getDate() === 1;
+  }
+
+  /**
+   * Check if date is last day of month
+   */
+  isLastDayOfMonth(date: Date | string | number): boolean {
+    const d = this.parse(date);
+    const tomorrow = new Date(d);
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    return tomorrow.getMonth() !== d.getMonth();
+  }
+
+  /**
+   * Get number of days in month
+   */
+  getDaysInMonth(date: Date | string | number): number {
+    const d = this.parse(date);
+    const year = d.getFullYear();
+    const month = d.getMonth();
+    return new Date(year, month + 1, 0).getDate();
+  }
+
+  private parse(date: Date | string | number): Date {
+    if (date instanceof Date) return new Date(date.getTime());
+    return new Date(date);
+  }
+}

package/src/timezone/infrastructure/services/CalendarManager.ts

@@ -0,0 +1,183 @@
+import { CalendarDay } from '../../domain/entities/Timezone';
+
+/**
+ * CalendarManager
+ * Handles calendar grid generation and date comparisons
+ */
+export class CalendarManager {
+    /**
+     * Get calendar days for a specific month
+     */
+    getCalendarDays(
+        year: number,
+        month: number,
+        formatDateFn: (date: Date) => string,
+    ): CalendarDay[] {
+        const days: CalendarDay[] = [];
+        const firstDay = new Date(year, month, 1);
+        const firstDayOfWeek = firstDay.getDay();
+        const lastDay = new Date(year, month + 1, 0);
+        const lastDayOfMonth = lastDay.getDate();
+        const today = new Date();
+
+        // Previous month filler
+        const prevMonthDate = new Date(year, month, 0);
+        const prevMonthLastDay = prevMonthDate.getDate();
+        const prevMonth = prevMonthDate.getMonth();
+        const prevYear = prevMonthDate.getFullYear();
+
+        for (let i = firstDayOfWeek - 1; i >= 0; i--) {
+            const day = prevMonthLastDay - i;
+            const date = new Date(prevYear, prevMonth, day);
+            days.push(this.createDay(date, false, today, formatDateFn));
+        }
+
+        // Current month
+        for (let day = 1; day <= lastDayOfMonth; day++) {
+            const date = new Date(year, month, day);
+            days.push(this.createDay(date, true, today, formatDateFn));
+        }
+
+        // Next month filler
+        const remainingDays = 42 - days.length;
+        const nextMonthDate = new Date(year, month + 1, 1);
+        const nextMonth = nextMonthDate.getMonth();
+        const nextYear = nextMonthDate.getFullYear();
+
+        for (let day = 1; day <= remainingDays; day++) {
+            const date = new Date(nextYear, nextMonth, day);
+            days.push(this.createDay(date, false, today, formatDateFn));
+        }
+
+        return days;
+    }
+
+    private createDay(
+        date: Date,
+        isCurrentMonth: boolean,
+        today: Date,
+        formatDateFn: (date: Date) => string,
+    ): CalendarDay {
+        return {
+            date,
+            day: date.getDate(),
+            dayOfWeek: date.getDay(),
+            month: date.getMonth(),
+            year: date.getFullYear(),
+            isCurrentMonth,
+            isToday: this.isSameDay(date, today),
+            isoDate: formatDateFn(date),
+        };
+    }
+
+    isSameDay(date1: Date | string | number, date2: Date | string | number): boolean {
+        const d1 = this.parse(date1);
+        const d2 = this.parse(date2);
+        return (
+            d1.getFullYear() === d2.getFullYear() &&
+            d1.getMonth() === d2.getMonth() &&
+            d1.getDate() === d2.getDate()
+        );
+    }
+
+    isToday(date: Date | string | number): boolean {
+        return this.isSameDay(date, new Date());
+    }
+
+    addDays(date: Date | string | number, days: number): Date {
+        const result = this.parse(date);
+        result.setDate(result.getDate() + days);
+        return result;
+    }
+
+    startOfDay(date: Date | string | number): Date {
+        const result = this.parse(date);
+        result.setHours(0, 0, 0, 0);
+        return result;
+    }
+
+    endOfDay(date: Date | string | number): Date {
+        const result = this.parse(date);
+        result.setHours(23, 59, 59, 999);
+        return result;
+    }
+
+    getDifferenceInDays(date1: Date | string | number, date2: Date | string | number): number {
+        const d1 = this.parse(date1);
+        const d2 = this.parse(date2);
+        const diffInMs = d1.getTime() - d2.getTime();
+        return Math.ceil(diffInMs / (1000 * 60 * 60 * 24));
+    }
+
+    getDaysUntil(date: Date | string | number): number {
+        const diff = this.getDifferenceInDays(this.parse(date), new Date());
+        return Math.max(0, diff);
+    }
+
+    isFuture(date: Date | string | number): boolean {
+        return this.parse(date).getTime() > Date.now();
+    }
+
+    isPast(date: Date | string | number): boolean {
+        return this.parse(date).getTime() < Date.now();
+    }
+
+    parse(date: Date | string | number): Date {
+        if (date instanceof Date) return new Date(date.getTime());
+        return new Date(date);
+    }
+
+    isValid(date: Date | string | number): boolean {
+        const d = this.parse(date);
+        return d instanceof Date && !isNaN(d.getTime());
+    }
+
+    getAge(birthDate: Date | string | number): number {
+        const birth = this.parse(birthDate);
+        const today = new Date();
+        let age = today.getFullYear() - birth.getFullYear();
+        const monthDiff = today.getMonth() - birth.getMonth();
+
+        if (monthDiff < 0 || (monthDiff === 0 && today.getDate() < birth.getDate())) {
+            age--;
+        }
+
+        return age;
+    }
+
+    isBetween(
+        date: Date | string | number,
+        start: Date | string | number,
+        end: Date | string | number,
+    ): boolean {
+        const d = this.parse(date).getTime();
+        const s = this.parse(start).getTime();
+        const e = this.parse(end).getTime();
+        return d >= s && d <= e;
+    }
+
+    min(dates: Array<Date | string | number>): Date {
+        const parsedDates = dates.map((d) => this.parse(d).getTime());
+        const minTime = Math.min(...parsedDates);
+        return new Date(minTime);
+    }
+
+    max(dates: Array<Date | string | number>): Date {
+        const parsedDates = dates.map((d) => this.parse(d).getTime());
+        const maxTime = Math.max(...parsedDates);
+        return new Date(maxTime);
+    }
+
+    getWeek(date: Date | string | number): number {
+        const d = this.parse(date);
+        d.setHours(0, 0, 0, 0);
+        d.setDate(d.getDate() + 4 - (d.getDay() || 7));
+        const yearStart = new Date(d.getFullYear(), 0, 1);
+        return Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);
+    }
+
+    getQuarter(date: Date | string | number): number {
+        const d = this.parse(date);
+        return Math.floor(d.getMonth() / 3) + 1;
+    }
+}

package/src/timezone/infrastructure/services/DateComparisonUtils.ts

@@ -0,0 +1,90 @@
+/**
+ * DateComparisonUtils
+ *
+ * Precise date comparison utilities and relative time formatting
+ * Handles hour/minute precision comparisons and "from now" formatting
+ */
+
+export class DateComparisonUtils {
+  /**
+   * Check if two dates are same hour
+   */
+  areSameHour(date1: Date | string | number, date2: Date | string | number): boolean {
+    const d1 = this.parse(date1);
+    const d2 = this.parse(date2);
+
+    return (
+      d1.getFullYear() === d2.getFullYear() &&
+      d1.getMonth() === d2.getMonth() &&
+      d1.getDate() === d2.getDate() &&
+      d1.getHours() === d2.getHours()
+    );
+  }
+
+  /**
+   * Check if two dates are same minute
+   */
+  areSameMinute(date1: Date | string | number, date2: Date | string | number): boolean {
+    const d1 = this.parse(date1);
+    const d2 = this.parse(date2);
+
+    return (
+      d1.getFullYear() === d2.getFullYear() &&
+      d1.getMonth() === d2.getMonth() &&
+      d1.getDate() === d2.getDate() &&
+      d1.getHours() === d2.getHours() &&
+      d1.getMinutes() === d2.getMinutes()
+    );
+  }
+
+  /**
+   * Get middle of day (12:00:00)
+   */
+  getMiddleOfDay(date: Date | string | number): Date {
+    const d = this.parse(date);
+    d.setHours(12, 0, 0, 0);
+    return d;
+  }
+
+  /**
+   * Get relative time from now ("5 minutes ago", "in 2 hours")
+   */
+  fromNow(date: Date | string | number, locale: string): string {
+    const d = this.parse(date);
+    const now = new Date();
+    const diffInMs = d.getTime() - now.getTime();
+    const diffInSeconds = Math.abs(diffInMs) / 1000;
+    const diffInMinutes = diffInSeconds / 60;
+    const diffInHours = diffInMinutes / 60;
+    const diffInDays = diffInHours / 24;
+
+    const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+
+    if (diffInSeconds < 60) {
+      return rtf.format(Math.round(diffInMs / 1000), 'second');
+    }
+
+    if (diffInMinutes < 60) {
+      return rtf.format(Math.round(diffInMs / (1000 * 60)), 'minute');
+    }
+
+    if (diffInHours < 24) {
+      return rtf.format(Math.round(diffInMs / (1000 * 60 * 60)), 'hour');
+    }
+
+    if (diffInDays < 30) {
+      return rtf.format(Math.round(diffInMs / (1000 * 60 * 60 * 24)), 'day');
+    }
+
+    if (diffInDays < 365) {
+      return rtf.format(Math.round(diffInDays / 30), 'month');
+    }
+
+    return rtf.format(Math.round(diffInDays / 365), 'year');
+  }
+
+  private parse(date: Date | string | number): Date {
+    if (date instanceof Date) return new Date(date.getTime());
+    return new Date(date);
+  }
+}

package/src/timezone/infrastructure/services/DateFormatter.ts

@@ -0,0 +1,134 @@
+/**
+ * DateFormatter
+ * Handles locale-aware formatting of dates and times
+ */
+export class DateFormatter {
+    formatDate(
+        date: Date | string | number,
+        locale: string,
+        options?: Intl.DateTimeFormatOptions,
+    ): string {
+        const defaultOptions: Intl.DateTimeFormatOptions = {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            ...options,
+        };
+        return new Intl.DateTimeFormat(locale, defaultOptions).format(this.parse(date));
+    }
+
+    formatTime(
+        date: Date | string | number,
+        locale: string,
+        options?: Intl.DateTimeFormatOptions,
+    ): string {
+        const defaultOptions: Intl.DateTimeFormatOptions = {
+            hour: 'numeric',
+            minute: '2-digit',
+            ...options,
+        };
+        return new Intl.DateTimeFormat(locale, defaultOptions).format(this.parse(date));
+    }
+
+    formatDateTime(
+        date: Date | string | number,
+        locale: string,
+        options?: Intl.DateTimeFormatOptions,
+    ): string {
+        const defaultOptions: Intl.DateTimeFormatOptions = {
+            year: 'numeric',
+            month: 'short',
+            day: 'numeric',
+            hour: '2-digit',
+            minute: '2-digit',
+            ...options,
+        };
+        return new Intl.DateTimeFormat(locale, defaultOptions).format(this.parse(date));
+    }
+
+    formatDateToString(date: Date | string | number): string {
+        const d = this.parse(date);
+        const y = d.getFullYear();
+        const m = String(d.getMonth() + 1).padStart(2, '0');
+        const day = String(d.getDate()).padStart(2, '0');
+        return `${y}-${m}-${day}`;
+    }
+
+    formatToISOString(date: Date | string | number): string {
+        return this.parse(date).toISOString();
+    }
+
+    formatToDisplayDate(date: Date | string | number): string {
+        const d = this.parse(date);
+        const day = String(d.getDate()).padStart(2, '0');
+        const m = String(d.getMonth() + 1).padStart(2, '0');
+        const y = d.getFullYear();
+        return `${day}.${m}.${y}`;
+    }
+
+    formatToDisplayDateTime(date: Date | string | number): string {
+        const d = this.parse(date);
+        const day = String(d.getDate()).padStart(2, '0');
+        const m = String(d.getMonth() + 1).padStart(2, '0');
+        const y = d.getFullYear();
+        const th = String(d.getHours()).padStart(2, '0');
+        const tm = String(d.getMinutes()).padStart(2, '0');
+        return `${day}.${m}.${y} ${th}:${tm}`;
+    }
+
+    formatRelativeTime(date: Date | string | number, locale: string): string {
+        const d = this.parse(date);
+        const now = new Date();
+        const diffInMs = d.getTime() - now.getTime();
+        const diffInDays = Math.round(diffInMs / (1000 * 60 * 60 * 24));
+
+        // Use Intl.RelativeTimeFormat for generic localizable relative time
+        const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+
+        if (Math.abs(diffInDays) < 7) {
+            return rtf.format(diffInDays, 'day');
+        }
+
+        // For longer periods, fall back to simple date
+        return this.formatDate(d, locale, {
+            month: 'short',
+            day: 'numeric',
+            year: Math.abs(diffInDays) > 365 ? 'numeric' : undefined,
+        });
+    }
+
+    parse(date: Date | string | number): Date {
+        if (date instanceof Date) return new Date(date.getTime());
+        return new Date(date);
+    }
+
+    formatDuration(milliseconds: number): string {
+        const seconds = Math.floor(milliseconds / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        const days = Math.floor(hours / 24);
+
+        const parts = [];
+
+        if (days > 0) {
+            parts.push(`${days}d`);
+        }
+
+        const remainingHours = hours % 24;
+        if (remainingHours > 0) {
+            parts.push(`${remainingHours}h`);
+        }
+
+        const remainingMinutes = minutes % 60;
+        if (remainingMinutes > 0) {
+            parts.push(`${remainingMinutes}m`);
+        }
+
+        const remainingSeconds = seconds % 60;
+        if (remainingSeconds > 0 || parts.length === 0) {
+            parts.push(`${remainingSeconds}s`);
+        }
+
+        return parts.join(' ');
+    }
+}

package/src/timezone/infrastructure/services/DateRangeUtils.ts

@@ -0,0 +1,64 @@
+/**
+ * DateRangeUtils
+ *
+ * Date range utilities for working with date intervals
+ * Handles range generation, overlap detection, and clamping
+ */
+
+export class DateRangeUtils {
+  /**
+   * Get array of dates in range (inclusive)
+   */
+  getDateRange(start: Date | string | number, end: Date | string | number): Date[] {
+    const startDate = this.parse(start);
+    const endDate = this.parse(end);
+    const dates: Date[] = [];
+
+    const current = new Date(startDate);
+    while (current <= endDate) {
+      dates.push(new Date(current));
+      current.setDate(current.getDate() + 1);
+    }
+
+    return dates;
+  }
+
+  /**
+   * Check if two date ranges overlap
+   */
+  areRangesOverlapping(
+    start1: Date | string | number,
+    end1: Date | string | number,
+    start2: Date | string | number,
+    end2: Date | string | number,
+  ): boolean {
+    const s1 = this.parse(start1).getTime();
+    const e1 = this.parse(end1).getTime();
+    const s2 = this.parse(start2).getTime();
+    const e2 = this.parse(end2).getTime();
+
+    return s1 <= e2 && e1 >= s2;
+  }
+
+  /**
+   * Clamp date to range
+   */
+  clampDate(
+    date: Date | string | number,
+    min: Date | string | number,
+    max: Date | string | number,
+  ): Date {
+    const d = this.parse(date).getTime();
+    const minTime = this.parse(min).getTime();
+    const maxTime = this.parse(max).getTime();
+
+    if (d < minTime) return this.parse(min);
+    if (d > maxTime) return this.parse(max);
+    return this.parse(date);
+  }
+
+  private parse(date: Date | string | number): Date {
+    if (date instanceof Date) return new Date(date.getTime());
+    return new Date(date);
+  }
+}

package/src/timezone/infrastructure/services/TimezoneProvider.ts

@@ -0,0 +1,132 @@
+import { TimezoneInfo } from '../../domain/entities/Timezone';
+import { SimpleCache } from '../utils/SimpleCache';
+
+/**
+ * TimezoneProvider
+ * Responsible for discovering device timezone and providing available timezones
+ */
+export class TimezoneProvider {
+    private cache = new SimpleCache<TimezoneInfo[]>(300000); // 5 min cache
+    /**
+     * Get current device timezone using Intl API
+     */
+    getCurrentTimezone(): string {
+        return Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+
+    /**
+     * Get current timezone offset in minutes
+     */
+    getTimezoneOffset(): number {
+        return new Date().getTimezoneOffset() * -1;
+    }
+
+    /**
+     * Get complete timezone information
+     */
+    getTimezoneInfo(): TimezoneInfo {
+        const timezone = this.getCurrentTimezone();
+        const offset = this.getTimezoneOffset();
+
+        const formatter = new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            timeZoneName: 'long',
+        });
+
+        const parts = formatter.formatToParts(new Date());
+        const timeZoneNamePart = parts.find((part) => part.type === 'timeZoneName');
+        const displayName = timeZoneNamePart?.value || timezone;
+
+        return {
+            timezone,
+            offset,
+            displayName,
+        };
+    }
+
+    /**
+     * Get list of common timezones (cached)
+     * Generic implementation for all apps
+     */
+    getTimezones(): TimezoneInfo[] {
+        const cached = this.cache.get('timezones');
+        if (cached) {
+            return cached;
+        }
+
+        const commonZones = [
+            'UTC',
+            'Europe/London',
+            'Europe/Paris',
+            'Europe/Istanbul',
+            'America/New_York',
+            'America/Los_Angeles',
+            'America/Chicago',
+            'Asia/Tokyo',
+            'Asia/Dubai',
+            'Asia/Shanghai',
+            'Australia/Sydney',
+        ];
+
+        const result = commonZones.map((zone) => {
+            try {
+                const formatter = new Intl.DateTimeFormat('en-US', {
+                    timeZone: zone,
+                    timeZoneName: 'long',
+                });
+                const parts = formatter.formatToParts(new Date());
+                const namePart = parts.find((p) => p.type === 'timeZoneName');
+
+                const offset = this.getTimezoneOffsetFor(zone);
+
+                return {
+                    timezone: zone,
+                    displayName: namePart?.value || zone,
+                    offset,
+                };
+            } catch (e) {
+                return {
+                    timezone: zone,
+                    displayName: zone,
+                    offset: 0,
+                };
+            }
+        });
+
+        this.cache.set('timezones', result);
+        return result;
+    }
+
+    /**
+     * Get timezone offset for specific timezone in minutes
+     */
+    getTimezoneOffsetFor(timezone: string, date: Date | string | number = new Date()): number {
+        try {
+            const d = date instanceof Date ? date : new Date(date);
+
+            const utcDate = new Date(d.toLocaleString('en-US', { timeZone: 'UTC' }));
+            const tzDate = new Date(d.toLocaleString('en-US', { timeZone: timezone }));
+
+            return (tzDate.getTime() - utcDate.getTime()) / (1000 * 60);
+        } catch (e) {
+            return 0;
+        }
+    }
+
+    /**
+     * Convert date from one timezone to another
+     */
+    convertTimezone(
+        date: Date | string | number,
+        fromTimezone: string,
+        toTimezone: string,
+    ): Date {
+        const d = date instanceof Date ? date : new Date(date);
+
+        const fromOffset = this.getTimezoneOffsetFor(fromTimezone, d);
+        const toOffset = this.getTimezoneOffsetFor(toTimezone, d);
+
+        const offsetDiff = toOffset - fromOffset;
+        return new Date(d.getTime() + offsetDiff * 60000);
+    }
+}

package/src/timezone/infrastructure/services/TimezoneService.ts

@@ -0,0 +1,148 @@
+/**
+ * Timezone Service Implementation
+ * Infrastructure Layer - Facade for all timezone operations
+ */
+
+import {
+  ITimezoneService,
+  TimezoneInfo,
+  CalendarDay,
+} from '../../domain/entities/Timezone';
+import { TimezoneProvider } from './TimezoneProvider';
+import { CalendarManager } from './CalendarManager';
+import { BusinessCalendarManager } from './BusinessCalendarManager';
+import { DateRangeUtils } from './DateRangeUtils';
+import { DateComparisonUtils } from './DateComparisonUtils';
+import { DateFormatter } from './DateFormatter';
+
+export class TimezoneService implements ITimezoneService {
+  private provider = new TimezoneProvider();
+  private calendar = new CalendarManager();
+  private businessCalendar = new BusinessCalendarManager();
+  private rangeUtils = new DateRangeUtils();
+  private comparisonUtils = new DateComparisonUtils();
+  private formatter = new DateFormatter();
+
+  getCurrentTimezone(): string { return this.provider.getCurrentTimezone(); }
+  getTimezoneOffset(): number { return this.provider.getTimezoneOffset(); }
+  getTimezoneInfo(): TimezoneInfo { return this.provider.getTimezoneInfo(); }
+  getTimezones(): TimezoneInfo[] { return this.provider.getTimezones(); }
+
+  formatDate(date: Date | string | number, locale: string, options?: Intl.DateTimeFormatOptions): string {
+    return this.formatter.formatDate(date, locale, options);
+  }
+
+  formatTime(date: Date | string | number, locale: string, options?: Intl.DateTimeFormatOptions): string {
+    return this.formatter.formatTime(date, locale, options);
+  }
+
+  formatDateTime(date: Date | string | number, locale: string, options?: Intl.DateTimeFormatOptions): string {
+    return this.formatter.formatDateTime(date, locale, options);
+  }
+
+  getCalendarDays(year: number, month: number): CalendarDay[] {
+    return this.calendar.getCalendarDays(year, month, (d) => this.formatter.formatDateToString(d));
+  }
+
+  isToday(date: Date | string | number): boolean { return this.calendar.isToday(date); }
+  isSameDay(date1: Date | string | number, date2: Date | string | number): boolean {
+    return this.calendar.isSameDay(date1, date2);
+  }
+
+  addDays(date: Date | string | number, days: number): Date { return this.calendar.addDays(date, days); }
+  startOfDay(date: Date | string | number): Date { return this.calendar.startOfDay(date); }
+  endOfDay(date: Date | string | number): Date { return this.calendar.endOfDay(date); }
+
+  formatDateToString(date: Date | string | number): string { return this.formatter.formatDateToString(date); }
+  getCurrentISOString(): string { return this.formatter.formatToISOString(new Date()); }
+  formatToISOString(date: Date | string | number): string { return this.formatter.formatToISOString(date); }
+  formatToDisplayDate(date: Date | string | number): string { return this.formatter.formatToDisplayDate(date); }
+  getNow(): Date { return new Date(); }
+
+  parse(date: Date | string | number): Date { return this.calendar.parse(date); }
+
+  formatToDisplayDateTime(date: Date | string | number): string {
+    return this.formatter.formatToDisplayDateTime(date);
+  }
+
+  formatRelativeTime(date: Date | string | number, locale: string): string {
+    return this.formatter.formatRelativeTime(date, locale);
+  }
+
+  isFuture(date: Date | string | number): boolean { return this.calendar.isFuture(date); }
+  isPast(date: Date | string | number): boolean { return this.calendar.isPast(date); }
+  getDaysUntil(date: Date | string | number): number { return this.calendar.getDaysUntil(date); }
+
+  getDifferenceInDays(date1: Date | string | number, date2: Date | string | number): number {
+    return this.calendar.getDifferenceInDays(date1, date2);
+  }
+
+  isValid(date: Date | string | number): boolean { return this.calendar.isValid(date); }
+  getAge(birthDate: Date | string | number): number { return this.calendar.getAge(birthDate); }
+
+  isBetween(date: Date | string | number, start: Date | string | number, end: Date | string | number): boolean {
+    return this.calendar.isBetween(date, start, end);
+  }
+
+  min(dates: Array<Date | string | number>): Date { return this.calendar.min(dates); }
+  max(dates: Array<Date | string | number>): Date { return this.calendar.max(dates); }
+  getWeek(date: Date | string | number): number { return this.calendar.getWeek(date); }
+  getQuarter(date: Date | string | number): number { return this.calendar.getQuarter(date); }
+
+  getTimezoneOffsetFor(timezone: string, date?: Date | string | number): number {
+    return this.provider.getTimezoneOffsetFor(timezone, date);
+  }
+
+  convertTimezone(date: Date | string | number, fromTimezone: string, toTimezone: string): Date {
+    return this.provider.convertTimezone(date, fromTimezone, toTimezone);
+  }
+
+  formatDuration(milliseconds: number): string { return this.formatter.formatDuration(milliseconds); }
+
+  isWeekend(date: Date | string | number): boolean { return this.businessCalendar.isWeekend(date); }
+
+  addBusinessDays(date: Date | string | number, days: number): Date {
+    return this.businessCalendar.addBusinessDays(date, days);
+  }
+
+  isFirstDayOfMonth(date: Date | string | number): boolean {
+    return this.businessCalendar.isFirstDayOfMonth(date);
+  }
+
+  isLastDayOfMonth(date: Date | string | number): boolean {
+    return this.businessCalendar.isLastDayOfMonth(date);
+  }
+
+  getDaysInMonth(date: Date | string | number): number { return this.businessCalendar.getDaysInMonth(date); }
+
+  getDateRange(start: Date | string | number, end: Date | string | number): Date[] {
+    return this.rangeUtils.getDateRange(start, end);
+  }
+
+  areRangesOverlapping(
+    start1: Date | string | number,
+    end1: Date | string | number,
+    start2: Date | string | number,
+    end2: Date | string | number,
+  ): boolean { return this.rangeUtils.areRangesOverlapping(start1, end1, start2, end2); }
+
+  clampDate(date: Date | string | number, min: Date | string | number, max: Date | string | number): Date {
+    return this.rangeUtils.clampDate(date, min, max);
+  }
+
+  areSameHour(date1: Date | string | number, date2: Date | string | number): boolean {
+    return this.comparisonUtils.areSameHour(date1, date2);
+  }
+
+  areSameMinute(date1: Date | string | number, date2: Date | string | number): boolean {
+    return this.comparisonUtils.areSameMinute(date1, date2);
+  }
+
+  getMiddleOfDay(date: Date | string | number): Date { return this.comparisonUtils.getMiddleOfDay(date); }
+
+  fromNow(date: Date | string | number, locale?: string): string {
+    return this.comparisonUtils.fromNow(date, locale || 'en');
+  }
+}
+
+export const timezoneService = new TimezoneService();

package/src/timezone/infrastructure/utils/SimpleCache.ts

@@ -0,0 +1,64 @@
+/**
+ * SimpleCache
+ *
+ * Lightweight in-memory cache for performance optimization
+ * No external dependencies - pure TypeScript implementation
+ */
+
+interface CacheEntry<T> {
+  value: T;
+  expires: number;
+}
+
+export class SimpleCache<T> {
+  private cache = new Map<string, CacheEntry<T>>();
+  private defaultTTL: number;
+
+  constructor(defaultTTL: number = 60000) {
+    this.defaultTTL = defaultTTL;
+    this.cleanup();
+  }
+
+  set(key: string, value: T, ttl?: number): void {
+    const expires = Date.now() + (ttl ?? this.defaultTTL);
+    this.cache.set(key, { value, expires });
+  }
+
+  get(key: string): T | undefined {
+    const entry = this.cache.get(key);
+
+    if (!entry) {
+      return undefined;
+    }
+
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return undefined;
+    }
+
+    return entry.value;
+  }
+
+  has(key: string): boolean {
+    return this.get(key) !== undefined;
+  }
+
+  clear(): void {
+    this.cache.clear();
+  }
+
+  delete(key: string): void {
+    this.cache.delete(key);
+  }
+
+  private cleanup(): void {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now > entry.expires) {
+        this.cache.delete(key);
+      }
+    }
+
+    setTimeout(() => this.cleanup(), 60000);
+  }
+}

package/src/timezone/presentation/hooks/useTimezone.ts

@@ -0,0 +1,155 @@
+/**
+ * useTimezone Hook
+ *
+ * React hook for timezone operations with automatic locale integration
+ * Integrates with localization package for locale-aware date/time formatting
+ */
+
+import { useMemo, useCallback } from 'react';
+import { useLocalization } from '@umituz/react-native-localization';
+import { timezoneService } from '../../infrastructure/services/TimezoneService';
+import type { TimezoneInfo, CalendarDay } from '../../domain/entities/Timezone';
+
+export interface UseTimezoneReturn {
+  timezone: string;
+  timezoneInfo: TimezoneInfo;
+  formatDate: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+  formatTime: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+  getCalendarDays: (year: number, month: number) => CalendarDay[];
+  isToday: (date: Date) => boolean;
+  isSameDay: (date1: Date, date2: Date) => boolean;
+  addDays: (date: Date, days: number) => Date;
+  startOfDay: (date: Date) => Date;
+  endOfDay: (date: Date) => Date;
+  formatDateToString: (date: Date) => string;
+  getCurrentISOString: () => string;
+  formatToISOString: (date: Date) => string;
+  formatRelativeTime: (date: Date) => string;
+  formatDateTime: (date: Date, options?: Intl.DateTimeFormatOptions) => string;
+  getTimezones: () => TimezoneInfo[];
+  isValid: (date: Date) => boolean;
+  getAge: (birthDate: Date) => number;
+  isBetween: (date: Date, start: Date, end: Date) => boolean;
+  min: (dates: Date[]) => Date;
+  max: (dates: Date[]) => Date;
+  getWeek: (date: Date) => number;
+  getQuarter: (date: Date) => number;
+  getTimezoneOffsetFor: (timezone: string, date?: Date) => number;
+  convertTimezone: (date: Date, fromTimezone: string, toTimezone: string) => Date;
+  formatDuration: (milliseconds: number) => string;
+  isWeekend: (date: Date) => boolean;
+  addBusinessDays: (date: Date, days: number) => Date;
+  isFirstDayOfMonth: (date: Date) => boolean;
+  isLastDayOfMonth: (date: Date) => boolean;
+  getDaysInMonth: (date: Date) => number;
+  getDateRange: (start: Date, end: Date) => Date[];
+  areRangesOverlapping: (start1: Date, end1: Date, start2: Date, end2: Date) => boolean;
+  clampDate: (date: Date, min: Date, max: Date) => Date;
+  areSameHour: (date1: Date, date2: Date) => boolean;
+  areSameMinute: (date1: Date, date2: Date) => boolean;
+  getMiddleOfDay: (date: Date) => Date;
+  fromNow: (date: Date) => string;
+}
+
+export const useTimezone = (): UseTimezoneReturn => {
+  const { currentLanguage } = useLocalization();
+  const timezoneInfo = useMemo(() => timezoneService.getTimezoneInfo(), []);
+
+  const formatDate = useCallback((date: Date, options?: Intl.DateTimeFormatOptions) =>
+    timezoneService.formatDate(date, currentLanguage, options), [currentLanguage]);
+
+  const formatTime = useCallback((date: Date, options?: Intl.DateTimeFormatOptions) =>
+    timezoneService.formatTime(date, currentLanguage, options), [currentLanguage]);
+
+  const formatDateTime = useCallback((date: Date, options?: Intl.DateTimeFormatOptions) =>
+    timezoneService.formatDateTime(date, currentLanguage, options), [currentLanguage]);
+
+  const formatRelativeTime = useCallback((date: Date) =>
+    timezoneService.formatRelativeTime(date, currentLanguage), [currentLanguage]);
+
+  const fromNow = useCallback((date: Date) =>
+    timezoneService.fromNow(date, currentLanguage), [currentLanguage]);
+
+  const getCalendarDays = useCallback((year: number, month: number) =>
+    timezoneService.getCalendarDays(year, month), []);
+
+  const isToday = useCallback((date: Date) => timezoneService.isToday(date), []);
+  const isSameDay = useCallback((date1: Date, date2: Date) => timezoneService.isSameDay(date1, date2), []);
+  const addDays = useCallback((date: Date, days: number) => timezoneService.addDays(date, days), []);
+  const startOfDay = useCallback((date: Date) => timezoneService.startOfDay(date), []);
+  const endOfDay = useCallback((date: Date) => timezoneService.endOfDay(date), []);
+  const formatDateToString = useCallback((date: Date) => timezoneService.formatDateToString(date), []);
+  const getCurrentISOString = useCallback(() => timezoneService.getCurrentISOString(), []);
+  const formatToISOString = useCallback((date: Date) => timezoneService.formatToISOString(date), []);
+  const getTimezones = useCallback(() => timezoneService.getTimezones(), []);
+  const isValid = useCallback((date: Date) => timezoneService.isValid(date), []);
+  const getAge = useCallback((birthDate: Date) => timezoneService.getAge(birthDate), []);
+  const isBetween = useCallback((date: Date, start: Date, end: Date) =>
+    timezoneService.isBetween(date, start, end), []);
+  const min = useCallback((dates: Date[]) => timezoneService.min(dates), []);
+  const max = useCallback((dates: Date[]) => timezoneService.max(dates), []);
+  const getWeek = useCallback((date: Date) => timezoneService.getWeek(date), []);
+  const getQuarter = useCallback((date: Date) => timezoneService.getQuarter(date), []);
+  const getTimezoneOffsetFor = useCallback((timezone: string, date?: Date) =>
+    timezoneService.getTimezoneOffsetFor(timezone, date), []);
+  const convertTimezone = useCallback((date: Date, fromTimezone: string, toTimezone: string) =>
+    timezoneService.convertTimezone(date, fromTimezone, toTimezone), []);
+  const formatDuration = useCallback((milliseconds: number) => timezoneService.formatDuration(milliseconds), []);
+  const isWeekend = useCallback((date: Date) => timezoneService.isWeekend(date), []);
+  const addBusinessDays = useCallback((date: Date, days: number) =>
+    timezoneService.addBusinessDays(date, days), []);
+  const isFirstDayOfMonth = useCallback((date: Date) => timezoneService.isFirstDayOfMonth(date), []);
+  const isLastDayOfMonth = useCallback((date: Date) => timezoneService.isLastDayOfMonth(date), []);
+  const getDaysInMonth = useCallback((date: Date) => timezoneService.getDaysInMonth(date), []);
+  const getDateRange = useCallback((start: Date, end: Date) => timezoneService.getDateRange(start, end), []);
+  const areRangesOverlapping = useCallback((start1: Date, end1: Date, start2: Date, end2: Date) =>
+    timezoneService.areRangesOverlapping(start1, end1, start2, end2), []);
+  const clampDate = useCallback((date: Date, min: Date, max: Date) =>
+    timezoneService.clampDate(date, min, max), []);
+  const areSameHour = useCallback((date1: Date, date2: Date) =>
+    timezoneService.areSameHour(date1, date2), []);
+  const areSameMinute = useCallback((date1: Date, date2: Date) =>
+    timezoneService.areSameMinute(date1, date2), []);
+  const getMiddleOfDay = useCallback((date: Date) => timezoneService.getMiddleOfDay(date), []);
+
+  return {
+    timezone: timezoneInfo.timezone || '',
+    timezoneInfo,
+    formatDate,
+    formatTime,
+    getCalendarDays,
+    isToday,
+    isSameDay,
+    addDays,
+    startOfDay,
+    endOfDay,
+    formatDateToString,
+    getCurrentISOString,
+    formatToISOString,
+    formatRelativeTime,
+    formatDateTime,
+    getTimezones,
+    isValid,
+    getAge,
+    isBetween,
+    min,
+    max,
+    getWeek,
+    getQuarter,
+    getTimezoneOffsetFor,
+    convertTimezone,
+    formatDuration,
+    isWeekend,
+    addBusinessDays,
+    isFirstDayOfMonth,
+    isLastDayOfMonth,
+    getDaysInMonth,
+    getDateRange,
+    areRangesOverlapping,
+    clampDate,
+    areSameHour,
+    areSameMinute,
+    getMiddleOfDay,
+    fromNow,
+  };
+};