@umituz/react-native-design-system 4.28.6 → 4.28.7

package/dist/molecules/calendar/domain/entities/CalendarEvent.entity.d.ts

@@ -1,140 +0,0 @@
-/**
- * CalendarEvent Entity
- *
- * Generic calendar event that can represent:
- * - Workouts (fitness apps)
- * - Habits (habit tracking apps)
- * - Tasks (productivity apps)
- * - Appointments (scheduling apps)
- * - Any other time-based event
- *
- * Design Philosophy:
- * - Generic and reusable across all app types
- * - Extensible via metadata field
- * - Simple core properties
- * - App-specific data in metadata
- */
-export interface CalendarEvent {
-    /**
-     * Unique identifier for the event
-     */
-    id: string;
-    /**
-     * Event title/name
-     * @example "Morning Workout", "Team Meeting", "Water plants"
-     */
-    title: string;
-    /**
-     * Event date in YYYY-MM-DD format (timezone-aware via timezone domain)
-     * @example "2024-10-30"
-     */
-    date: string;
-    /**
-     * Optional event time in HH:mm format
-     * @example "09:30", "14:00"
-     */
-    time?: string;
-    /**
-     * Optional event color for visual distinction
-     * Uses design token color names or hex values
-     * @example "primary", "success", "#FF5733"
-     */
-    color?: string;
-    /**
-     * Whether the event has been completed/checked off
-     * @default false
-     */
-    isCompleted?: boolean;
-    /**
-     * Optional duration in minutes
-     * @example 30, 60, 90
-     */
-    duration?: number;
-    /**
-     * Optional event description/notes
-     */
-    description?: string;
-    /**
-     * Optional location for the event
-     */
-    location?: string;
-    /**
-     * Reminders/alarms (minutes before event)
-     * @example [15, 30] → 15 mins and 30 mins before
-     */
-    reminders?: number[];
-    /**
-     * App-specific metadata
-     * Use this for domain-specific properties
-     * @example
-     * // Workout app:
-     * metadata: { workoutTemplateId: "abc123", exercises: [...] }
-     *
-     * // Habit app:
-     * metadata: { habitId: "xyz789", streak: 5 }
-     */
-    metadata?: unknown;
-    /**
-     * Recurring event configuration
-     */
-    recurring?: {
-        /**
-         * Recurrence pattern
-         */
-        pattern: 'daily' | 'weekly' | 'monthly' | 'custom';
-        /**
-         * Interval for recurrence
-         * @example pattern: 'weekly', interval: 2 → every 2 weeks
-         */
-        interval?: number;
-        /**
-         * Days of week for weekly recurrence (0 = Sunday, 6 = Saturday)
-         * @example [1, 3, 5] → Monday, Wednesday, Friday
-         */
-        daysOfWeek?: number[];
-        /**
-         * End date for recurrence (YYYY-MM-DD)
-         */
-        endDate?: string;
-    };
-    /**
-     * Creation timestamp
-     */
-    createdAt: Date;
-    /**
-     * Last update timestamp
-     */
-    updatedAt: Date;
-}
-/**
- * Request object for creating a new calendar event
- */
-export interface CreateCalendarEventRequest {
-    title: string;
-    date: string;
-    time?: string;
-    color?: string;
-    duration?: number;
-    description?: string;
-    location?: string;
-    reminders?: number[];
-    metadata?: unknown;
-    recurring?: CalendarEvent['recurring'];
-}
-/**
- * Request object for updating an existing calendar event
- */
-export interface UpdateCalendarEventRequest {
-    id: string;
-    title?: string;
-    date?: string;
-    time?: string;
-    color?: string;
-    isCompleted?: boolean;
-    duration?: number;
-    description?: string;
-    location?: string;
-    reminders?: number[];
-    metadata?: unknown;
-    recurring?: CalendarEvent['recurring'];
-}

package/dist/molecules/calendar/domain/repositories/ICalendarRepository.d.ts

@@ -1,101 +0,0 @@
-/**
- * ICalendarRepository Interface
- *
- * Port (interface) for calendar data access operations.
- * Implementations can use any storage mechanism (AsyncStorage, SQLite, etc.)
- *
- * Design Philosophy:
- * - Repository pattern (DDD)
- * - Storage-agnostic
- * - CRUD operations for calendar events
- * - Query methods for finding events
- */
-import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../entities/CalendarEvent.entity';
-export interface ICalendarRepository {
-    /**
-     * Get all calendar events
-     * @returns Promise resolving to array of all events
-     */
-    getAllEvents(): Promise<CalendarEvent[]>;
-    /**
-     * Get a calendar event by ID
-     * @param id - Event ID
-     * @returns Promise resolving to event or null if not found
-     */
-    getEventById(id: string): Promise<CalendarEvent | null>;
-    /**
-     * Get events for a specific date
-     * @param date - Date string in YYYY-MM-DD format
-     * @returns Promise resolving to array of events for that date
-     */
-    getEventsByDate(date: string): Promise<CalendarEvent[]>;
-    /**
-     * Get events within a date range
-     * @param startDate - Start date (YYYY-MM-DD)
-     * @param endDate - End date (YYYY-MM-DD)
-     * @returns Promise resolving to array of events in range
-     */
-    getEventsByDateRange(startDate: string, endDate: string): Promise<CalendarEvent[]>;
-    /**
-     * Get events for a specific month
-     * @param year - Year (e.g., 2024)
-     * @param month - Month (0-indexed: 0 = January, 11 = December)
-     * @returns Promise resolving to array of events in that month
-     */
-    getEventsByMonth(year: number, month: number): Promise<CalendarEvent[]>;
-    /**
-     * Create a new calendar event
-     * @param request - Event creation data
-     * @returns Promise resolving to created event
-     */
-    createEvent(request: CreateCalendarEventRequest): Promise<CalendarEvent>;
-    /**
-     * Update an existing calendar event
-     * @param request - Event update data (must include id)
-     * @returns Promise resolving to updated event
-     */
-    updateEvent(request: UpdateCalendarEventRequest): Promise<CalendarEvent>;
-    /**
-     * Delete a calendar event
-     * @param id - Event ID to delete
-     * @returns Promise resolving to void
-     */
-    deleteEvent(id: string): Promise<void>;
-    /**
-     * Delete all events for a specific date
-     * @param date - Date string in YYYY-MM-DD format
-     * @returns Promise resolving to number of deleted events
-     */
-    deleteEventsByDate(date: string): Promise<number>;
-    /**
-     * Mark an event as completed
-     * @param id - Event ID
-     * @returns Promise resolving to updated event
-     */
-    completeEvent(id: string): Promise<CalendarEvent>;
-    /**
-     * Mark an event as incomplete
-     * @param id - Event ID
-     * @returns Promise resolving to updated event
-     */
-    uncompleteEvent(id: string): Promise<CalendarEvent>;
-    /**
-     * Search events by title
-     * @param query - Search query string
-     * @returns Promise resolving to array of matching events
-     */
-    searchEvents(query: string): Promise<CalendarEvent[]>;
-    /**
-     * Get upcoming events (from today onwards)
-     * @param limit - Maximum number of events to return
-     * @returns Promise resolving to array of upcoming events
-     */
-    getUpcomingEvents(limit?: number): Promise<CalendarEvent[]>;
-    /**
-     * Get completed events count for a date range
-     * @param startDate - Start date (YYYY-MM-DD)
-     * @param endDate - End date (YYYY-MM-DD)
-     * @returns Promise resolving to count of completed events
-     */
-    getCompletedEventsCount(startDate: string, endDate: string): Promise<number>;
-}

package/dist/molecules/calendar/index.d.ts

@@ -1,39 +0,0 @@
-/**
- * Calendar Domain - Barrel Export
- *
- * Public API for the calendar domain.
- * Provides generic, reusable calendar functionality for all factory-generated apps.
- *
- * Features:
- * - Timezone-aware calendar generation (built-in DateUtilities)
- * - Generic event system (workouts, habits, tasks, etc.)
- * - Month/Week/Day views
- * - Event CRUD operations with persistence
- * - Completion tracking
- * - Recurring events support
- *
- * Usage:
- * ```tsx
- * import { useCalendar, AtomicCalendar } from '@umituz/react-native-design-system';
- *
- * const MyScreen = () => {
- *   const { days, selectedDate, actions } = useCalendar();
- *
- *   return (
- *     <AtomicCalendar
- *       days={days}
- *       selectedDate={selectedDate}
- *       onDateSelect={actions.setSelectedDate}
- *     />
- *   );
- * };
- * ```
- */
-export type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest, } from './domain/entities/CalendarEvent.entity';
-export type { CalendarDay, CalendarMonth, CalendarWeek, } from './domain/entities/CalendarDay.entity';
-export type { ICalendarRepository } from './domain/repositories/ICalendarRepository';
-export { CalendarService } from './infrastructure/services/CalendarService';
-export { CalendarGeneration } from './infrastructure/services/CalendarGeneration';
-export { DateUtilities } from './infrastructure/utils/DateUtilities';
-export { useCalendar, useCalendarEvents, useCalendarNavigation, useCalendarView, type CalendarViewMode, } from './infrastructure/storage/CalendarStore';
-export { AtomicCalendar, type AtomicCalendarProps, } from './presentation/components/AtomicCalendar';

package/dist/molecules/calendar/infrastructure/services/CalendarGeneration.d.ts

@@ -1,70 +0,0 @@
-/**
- * Calendar Generation Service
- *
- * Generates calendar grids and layouts.
- *
- * SOLID: Single Responsibility - Only calendar generation
- * DRY: Reusable calendar generation logic
- * KISS: Simple calendar grid creation
- */
-import type { CalendarDay } from '../../domain/entities/CalendarDay.entity';
-import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
-export declare class CalendarGeneration {
-    /**
-     * Generate calendar days for a specific month
-     * Returns 42 days (6 weeks) including days from prev/next months
-     */
-    static generateMonthDays(year: number, month: number, events?: CalendarEvent[]): CalendarDay[];
-    /**
-     * Generate calendar days for a specific week
-     */
-    static generateWeekDays(startDate: Date, events?: CalendarEvent[]): CalendarDay[];
-    /**
-     * Get events for a specific date
-     */
-    static getEventsForDate(date: Date, allEvents: CalendarEvent[]): CalendarEvent[];
-    /**
-     * Get events in date range
-     */
-    static getEventsInRange(startDate: Date, endDate: Date, events: CalendarEvent[]): CalendarEvent[];
-    /**
-     * Navigate to previous month
-     */
-    static getPreviousMonth(currentDate: Date): Date;
-    /**
-     * Navigate to next month
-     */
-    static getNextMonth(currentDate: Date): Date;
-    /**
-     * Navigate to previous week
-     */
-    static getPreviousWeek(currentDate: Date): Date;
-    /**
-     * Navigate to next week
-     */
-    static getNextWeek(currentDate: Date): Date;
-    /**
-     * Check if date is today
-     */
-    static isToday(date: Date): boolean;
-    /**
-     * Check if two dates are the same day
-     */
-    static isSameDay(date1: Date, date2: Date): boolean;
-    /**
-     * Format date for display
-     */
-    static formatDate(date: Date): string;
-    /**
-     * Get month name
-     */
-    static getMonthName(date: Date): string;
-    /**
-     * Get weekday name
-     */
-    static getWeekdayName(date: Date): string;
-    /**
-     * Get short weekday name
-     */
-    static getShortWeekdayName(date: Date): string;
-}

package/dist/molecules/calendar/infrastructure/services/CalendarService.d.ts

@@ -1,61 +0,0 @@
-/**
- * Calendar Service
- *
- * Facade for calendar operations using composition.
- * Delegates to specialized services for specific operations.
- *
- * SOLID: Facade pattern - Single entry point, delegates to specialists
- * DRY: Avoids code duplication by composing smaller services
- * KISS: Simple interface, complex operations delegated
- */
-import type { CalendarDay, CalendarWeek } from '../../domain/entities/CalendarDay.entity';
-import type { CalendarEvent } from '../../domain/entities/CalendarEvent.entity';
-/**
- * Calendar Service Implementation
- *
- * Facade that delegates to specialized services.
- * Follows SOLID principles with composition over inheritance.
- */
-export declare class CalendarService {
-    private static weekdayNamesCache;
-    /**
-     * Generate calendar days for a specific month
-     */
-    static getMonthDays(year: number, month: number, events?: CalendarEvent[]): CalendarDay[];
-    /**
-     * Generate calendar week
-     */
-    static getWeek(date: Date, events?: CalendarEvent[]): CalendarWeek;
-    /**
-     * Navigate to previous month
-     */
-    static getPreviousMonth(currentDate: Date): Date;
-    /**
-     * Navigate to next month
-     */
-    static getNextMonth(currentDate: Date): Date;
-    /**
-     * Navigate to previous week
-     */
-    static getPreviousWeek(currentDate: Date): Date;
-    /**
-     * Navigate to next week
-     */
-    static getNextWeek(currentDate: Date): Date;
-    /**
-     * Get events for a specific date
-     */
-    static getEventsForDate(date: Date, events: CalendarEvent[]): CalendarEvent[];
-    /**
-     * Get events in date range
-     */
-    static getEventsInRange(startDate: Date, endDate: Date, events: CalendarEvent[]): CalendarEvent[];
-    /**
-     * Get weekday names
-     */
-    static getWeekdayNames(locale?: string): string[];
-    /**
-     * Check if two dates are the same day
-     */
-    static isSameDay(date1: Date, date2: Date): boolean;
-}

package/dist/molecules/calendar/infrastructure/storage/CalendarStore.d.ts

@@ -1,64 +0,0 @@
-/**
- * Calendar Store - Combined Hook
- * Convenience hook that combines all calendar stores
- */
-export { useCalendarEvents } from '../stores/useCalendarEvents';
-export { useCalendarNavigation } from '../stores/useCalendarNavigation';
-export { useCalendarView } from '../stores/useCalendarView';
-export type { CalendarViewMode } from '../stores/useCalendarView';
-/**
- * Combined calendar hook
- * Use this for convenience, or use individual stores for fine-grained control
- */
-export declare const useCalendar: () => {
-    events: import("../..").CalendarEvent[];
-    isLoading: boolean;
-    error: string | null;
-    loadEvents: () => Promise<void>;
-    addEvent: (request: import("../..").CreateCalendarEventRequest) => Promise<void>;
-    updateEvent: (request: import("../..").UpdateCalendarEventRequest) => Promise<void>;
-    deleteEvent: (id: string) => Promise<void>;
-    completeEvent: (id: string) => Promise<void>;
-    uncompleteEvent: (id: string) => Promise<void>;
-    clearError: () => void;
-    clearAllEvents: () => Promise<void>;
-    selectedDate: Date;
-    currentMonth: Date;
-    setSelectedDate: (date: Date) => void;
-    goToToday: () => void;
-    navigateMonth: (direction: "prev" | "next") => void;
-    setCurrentMonth: (date: Date) => void;
-    viewMode: import("./CalendarStore").CalendarViewMode;
-    setViewMode: (mode: import("./CalendarStore").CalendarViewMode) => void;
-    getEventsForDate: (date: Date | null | undefined) => import("../..").CalendarEvent[];
-    getEventsForMonth: (year: number, month: number) => import("../..").CalendarEvent[];
-};
-/**
- * Combined calendar store hook with computed days
- */
-export declare const useCalendarStore: () => {
-    events: import("../..").CalendarEvent[];
-    selectedDate: Date;
-    currentMonth: Date;
-    viewMode: import("./CalendarStore").CalendarViewMode;
-    isLoading: boolean;
-    error: string | null;
-    actions: {
-        loadEvents: () => Promise<void>;
-        addEvent: (request: import("../..").CreateCalendarEventRequest) => Promise<void>;
-        updateEvent: (request: import("../..").UpdateCalendarEventRequest) => Promise<void>;
-        deleteEvent: (id: string) => Promise<void>;
-        completeEvent: (id: string) => Promise<void>;
-        uncompleteEvent: (id: string) => Promise<void>;
-        setSelectedDate: (date: Date) => void;
-        goToToday: () => void;
-        navigateMonth: (direction: "prev" | "next") => void;
-        setCurrentMonth: (date: Date) => void;
-        setViewMode: (mode: import("./CalendarStore").CalendarViewMode) => void;
-        getEventsForDate: (date: Date | null | undefined) => import("../..").CalendarEvent[];
-        getEventsForMonth: (year: number, month: number) => import("../..").CalendarEvent[];
-        clearError: () => void;
-        clearAllEvents: () => Promise<void>;
-    };
-    days: import("../..").CalendarDay[];
-};

package/dist/molecules/calendar/infrastructure/stores/storageAdapter.d.ts

@@ -1,9 +0,0 @@
-/**
- * AsyncStorage Adapter for Zustand Persist
- * Converts AsyncStorageRepository to Zustand-compatible storage
- */
-export declare const zustandStorage: {
-    getItem: (name: string) => Promise<string | null>;
-    setItem: (name: string, value: string) => Promise<void>;
-    removeItem: (name: string) => Promise<void>;
-};

package/dist/molecules/calendar/infrastructure/stores/useCalendarEvents.d.ts

@@ -1,24 +0,0 @@
-/**
- * Calendar Events Store
- * Manages event CRUD operations only
- * Uses manual persistence (no zustand persist middleware)
- */
-import type { CalendarEvent, CreateCalendarEventRequest, UpdateCalendarEventRequest } from '../../domain/entities/CalendarEvent.entity';
-interface CalendarEventsState {
-    readonly events: CalendarEvent[];
-    readonly isLoading: boolean;
-    readonly error: string | null;
-}
-interface CalendarEventsActions {
-    readonly loadEvents: () => Promise<void>;
-    readonly addEvent: (request: CreateCalendarEventRequest) => Promise<void>;
-    readonly updateEvent: (request: UpdateCalendarEventRequest) => Promise<void>;
-    readonly deleteEvent: (id: string) => Promise<void>;
-    readonly completeEvent: (id: string) => Promise<void>;
-    readonly uncompleteEvent: (id: string) => Promise<void>;
-    readonly clearError: () => void;
-    readonly clearAllEvents: () => Promise<void>;
-}
-type CalendarEventsStore = CalendarEventsState & CalendarEventsActions;
-export declare const useCalendarEvents: import("zustand").UseBoundStore<import("zustand").StoreApi<CalendarEventsStore>>;
-export {};

package/dist/molecules/calendar/infrastructure/stores/useCalendarNavigation.d.ts

@@ -1,17 +0,0 @@
-/**
- * Calendar Navigation Store
- * Manages date navigation state (no persistence needed)
- */
-interface CalendarNavigationState {
-    readonly selectedDate: Date;
-    readonly currentMonth: Date;
-}
-interface CalendarNavigationActions {
-    readonly setSelectedDate: (date: Date) => void;
-    readonly goToToday: () => void;
-    readonly navigateMonth: (direction: 'prev' | 'next') => void;
-    readonly setCurrentMonth: (date: Date) => void;
-}
-type CalendarNavigationStore = CalendarNavigationState & CalendarNavigationActions;
-export declare const useCalendarNavigation: import("zustand").UseBoundStore<import("zustand").StoreApi<CalendarNavigationStore>>;
-export {};

package/dist/molecules/calendar/infrastructure/stores/useCalendarView.d.ts

@@ -1,14 +0,0 @@
-/**
- * Calendar View Store
- * Manages calendar view mode (no persistence needed)
- */
-export type CalendarViewMode = 'month' | 'week' | 'day' | 'list';
-interface CalendarViewState {
-    readonly viewMode: CalendarViewMode;
-}
-interface CalendarViewActions {
-    readonly setViewMode: (mode: CalendarViewMode) => void;
-}
-type CalendarViewStore = CalendarViewState & CalendarViewActions;
-export declare const useCalendarView: import("zustand").UseBoundStore<import("zustand").StoreApi<CalendarViewStore>>;
-export {};

package/dist/molecules/calendar/infrastructure/utils/DateUtilities.d.ts

@@ -1,68 +0,0 @@
-/**
- * Date Utilities
- *
- * Pure functions for date operations and formatting.
- * No side effects, timezone-aware operations.
- *
- * SOLID: Single Responsibility - Only date operations
- * DRY: Reusable date utility functions
- * KISS: Simple, focused functions
- */
-export declare class DateUtilities {
-    /**
-     * Format date to string (YYYY-MM-DD)
-     */
-    static formatDateToString(date: Date): string;
-    /**
-     * Check if two dates are the same day
-     */
-    static isSameDay(date1: Date, date2: Date): boolean;
-    /**
-     * Add days to a date
-     */
-    static addDays(date: Date, days: number): Date;
-    /**
-     * Check if date is today
-     */
-    static isToday(date: Date): boolean;
-    /**
-     * Get current timezone
-     */
-    static getCurrentTimezone(): string;
-    /**
-     * Get start of month
-     */
-    static getStartOfMonth(date: Date): Date;
-    /**
-     * Get end of month
-     */
-    static getEndOfMonth(date: Date): Date;
-    /**
-     * Get number of days in month
-     */
-    static getDaysInMonth(date: Date): number;
-    /**
-     * Get start of week (Sunday)
-     */
-    static getStartOfWeek(date: Date): Date;
-    /**
-     * Get end of week (Saturday)
-     */
-    static getEndOfWeek(date: Date): Date;
-    /**
-     * Parse date from string (YYYY-MM-DD)
-     */
-    static parseDate(dateString: string): Date;
-    /**
-     * Format time to string (HH:MM)
-     */
-    static formatTimeToString(date: Date): string;
-    /**
-     * Check if date is in the past
-     */
-    static isPast(date: Date): boolean;
-    /**
-     * Check if date is in the future
-     */
-    static isFuture(date: Date): boolean;
-}