@umituz/react-native-design-system 4.25.99 → 4.25.100

package/dist/molecules/bottom-sheet/components/filter/FilterBottomSheet.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Presentation - Filter Bottom Sheet component
+ */
+import React from 'react';
+import type { BottomSheetModalRef } from '../../types/BottomSheet';
+import type { FilterCategory } from '../../types/Filter';
+export interface FilterBottomSheetProps {
+    readonly categories: FilterCategory[];
+    readonly selectedIds: string[];
+    readonly onFilterPress: (id: string, categoryId: string) => void;
+    readonly onDismiss?: () => void;
+    readonly title?: string;
+    readonly applyLabel?: string;
+    readonly defaultId?: string;
+}
+export declare const FilterBottomSheet: React.ForwardRefExoticComponent<FilterBottomSheetProps & React.RefAttributes<BottomSheetModalRef>>;

package/dist/molecules/bottom-sheet/components/filter/FilterSheet.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import type { FilterOption } from "../../types/Filter";
+export interface FilterSheetProps {
+    visible: boolean;
+    options: FilterOption[];
+    selectedIds: string[];
+    onFilterPress: (filterId: string) => void;
+    onClearFilters: () => void;
+    onClose?: () => void;
+    defaultFilterId?: string;
+    title?: string;
+    clearLabel?: string;
+}
+export declare const FilterSheet: React.FC<FilterSheetProps>;

package/dist/molecules/bottom-sheet/components/filter/FilterSheetComponents/FilterSheetHeader.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import type { useAppDesignTokens } from '../../../../../theme';
+interface FilterSheetHeaderProps {
+    title: string;
+    onClose: () => void;
+    tokens: ReturnType<typeof useAppDesignTokens>;
+}
+export declare const FilterSheetHeader: ({ title, onClose, tokens }: FilterSheetHeaderProps) => React.JSX.Element;
+export {};

package/dist/molecules/bottom-sheet/components/filter/FilterSheetComponents/FilterSheetOption.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import type { useAppDesignTokens } from '../../../../../theme';
+import type { FilterOption } from '../../../types/Filter';
+interface FilterSheetOptionProps {
+    option: FilterOption;
+    isSelected: boolean;
+    onPress: (id: string) => void;
+    tokens: ReturnType<typeof useAppDesignTokens>;
+}
+export declare const FilterSheetOption: ({ option, isSelected, onPress, tokens }: FilterSheetOptionProps) => React.JSX.Element;
+export {};

package/dist/molecules/bottom-sheet/hooks/useBottomSheet.d.ts

@@ -0,0 +1,2 @@
+import type { UseBottomSheetReturn } from '../types/BottomSheet';
+export declare const useBottomSheet: () => UseBottomSheetReturn;

package/dist/molecules/bottom-sheet/hooks/useBottomSheetModal.d.ts

@@ -0,0 +1,2 @@
+import type { UseBottomSheetModalReturn } from '../types/BottomSheet';
+export declare const useBottomSheetModal: () => UseBottomSheetModalReturn;

package/dist/molecules/bottom-sheet/hooks/useListFilters.d.ts

@@ -0,0 +1,26 @@
+/**
+ * useListFilters Hook
+ */
+import { FilterOption } from '../types/Filter';
+export interface FilterItem extends FilterOption {
+    active?: boolean;
+}
+export interface UseListFiltersReturn<T> {
+    filters: FilterItem[];
+    setFilters: (filters: FilterItem[]) => void;
+    activeFilters: FilterItem[];
+    selectedIds: string[];
+    applyFilters: (items: T[]) => T[];
+    toggleFilter: (id: string) => void;
+    handleFilterPress: (id: string) => void;
+    clearFilters: () => void;
+    handleClearFilters: () => void;
+}
+export interface UseListFiltersConfig<T> {
+    options: FilterOption[];
+    defaultFilterId?: string;
+    singleSelect?: boolean;
+    filterFn?: (item: T, activeFilters: FilterItem[]) => boolean;
+}
+export declare function useListFilters<T>(config: UseListFiltersConfig<T>): UseListFiltersReturn<T>;
+export declare function useListFilters<T>(initialFilters: FilterItem[], filterFn?: (item: T, activeFilters: FilterItem[]) => boolean): UseListFiltersReturn<T>;

package/dist/molecules/bottom-sheet/index.d.ts

@@ -0,0 +1,9 @@
+export * from './components/BottomSheet';
+export * from './components/BottomSheetModal';
+export * from './components/filter/FilterBottomSheet';
+export * from './components/filter/FilterSheet';
+export * from './hooks/useBottomSheet';
+export * from './hooks/useBottomSheetModal';
+export * from './hooks/useListFilters';
+export * from './types/BottomSheet';
+export * from './types/Filter';

package/dist/molecules/bottom-sheet/types/BottomSheet.d.ts

@@ -0,0 +1,72 @@
+import React from 'react';
+export type SnapPoint = string | number;
+export type BottomSheetPreset = 'small' | 'medium' | 'large' | 'full' | 'custom';
+export type KeyboardBehavior = 'interactive' | 'extend' | 'fillParent';
+export interface BottomSheetConfig {
+    snapPoints: SnapPoint[];
+    initialIndex?: number;
+    enableBackdrop?: boolean;
+    backdropAppearsOnIndex?: number;
+    backdropDisappearsOnIndex?: number;
+    keyboardBehavior?: KeyboardBehavior;
+    enableHandleIndicator?: boolean;
+    enablePanDownToClose?: boolean;
+    enableDynamicSizing?: boolean;
+}
+export interface BottomSheetRef {
+    snapToIndex: (index: number) => void;
+    snapToPosition: (position: string | number) => void;
+    expand: () => void;
+    collapse: () => void;
+    close: () => void;
+}
+export interface BottomSheetModalRef {
+    present: () => void;
+    dismiss: () => void;
+    snapToIndex: (index: number) => void;
+    snapToPosition: (position: string | number) => void;
+    expand: () => void;
+    collapse: () => void;
+}
+export interface BottomSheetProps {
+    children: React.ReactNode;
+    preset?: BottomSheetPreset;
+    snapPoints?: SnapPoint[];
+    initialIndex?: number;
+    enableBackdrop?: boolean;
+    backdropAppearsOnIndex?: number;
+    backdropDisappearsOnIndex?: number;
+    keyboardBehavior?: KeyboardBehavior;
+    enableHandleIndicator?: boolean;
+    enablePanDownToClose?: boolean;
+    enableDynamicSizing?: boolean;
+    backgroundColor?: string;
+    onChange?: (index: number) => void;
+    onClose?: () => void;
+}
+export interface BottomSheetModalProps extends Omit<BottomSheetProps, 'onClose'> {
+    onDismiss?: () => void;
+    backgroundColor?: string;
+}
+export interface UseBottomSheetReturn {
+    sheetRef: React.RefObject<BottomSheetRef | null>;
+    open: () => void;
+    close: () => void;
+    expand: () => void;
+    collapse: () => void;
+    snapToIndex: (index: number) => void;
+    snapToPosition: (position: string | number) => void;
+}
+export interface UseBottomSheetModalReturn {
+    modalRef: React.RefObject<BottomSheetModalRef | null>;
+    present: () => void;
+    dismiss: () => void;
+    snapToIndex: (index: number) => void;
+    snapToPosition: (position: string | number) => void;
+    expand: () => void;
+    collapse: () => void;
+}
+export declare const BottomSheetUtils: {
+    getPreset: (preset: BottomSheetPreset) => BottomSheetConfig;
+    createConfig: (config: Partial<BottomSheetConfig>) => BottomSheetConfig;
+};

package/dist/molecules/bottom-sheet/types/Filter.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Domain - Filter Entities
+ */
+export interface FilterOption {
+    id: string;
+    label: string;
+    icon?: string;
+    type?: string;
+    count?: number;
+}
+export interface FilterCategory {
+    id: string;
+    title: string;
+    options: FilterOption[];
+    multiSelect?: boolean;
+}
+export declare class FilterUtils {
+    static hasActiveFilter(selectedIds: string[], defaultId?: string): boolean;
+    static toggleFilter(selectedIds: string[], filterId: string, multiSelect?: boolean, defaultId?: string): string[];
+}

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

@@ -0,0 +1,98 @@
+/**
+ * CalendarDay Entity
+ *
+ * Represents a single day in a calendar view with its properties and associated events.
+ *
+ * Design Philosophy:
+ * - Timezone-aware (uses timezone domain for date calculations)
+ * - Event-agnostic (works with any CalendarEvent type)
+ * - View-ready (contains all display state)
+ * - Immutable (never mutate, create new instances)
+ */
+import type { CalendarEvent } from './CalendarEvent.entity';
+export interface CalendarDay {
+    /**
+     * The date this calendar day represents
+     */
+    date: Date;
+    /**
+     * Whether this day belongs to the currently displayed month
+     * Used to gray out days from prev/next months in calendar grid
+     */
+    isCurrentMonth: boolean;
+    /**
+     * Whether this day is today (timezone-aware via timezone domain)
+     */
+    isToday: boolean;
+    /**
+     * Whether this day is currently selected by the user
+     */
+    isSelected: boolean;
+    /**
+     * Events scheduled for this day
+     * @default []
+     */
+    events: CalendarEvent[];
+    /**
+     * Whether this day is disabled/non-selectable
+     * @example Past dates, dates outside valid range
+     * @default false
+     */
+    isDisabled?: boolean;
+    /**
+     * Whether this day is a weekend (Saturday or Sunday)
+     * Useful for styling weekend days differently
+     */
+    isWeekend?: boolean;
+}
+/**
+ * Calendar Month Configuration
+ *
+ * Represents a full month view with all necessary display information
+ */
+export interface CalendarMonth {
+    /**
+     * Year of the month
+     */
+    year: number;
+    /**
+     * Month (0-indexed: 0 = January, 11 = December)
+     */
+    month: number;
+    /**
+     * All days to display in the calendar grid (usually 42 days = 6 weeks)
+     * Includes days from previous and next months to fill the grid
+     */
+    days: CalendarDay[];
+    /**
+     * First day of the month
+     */
+    firstDay: Date;
+    /**
+     * Last day of the month
+     */
+    lastDay: Date;
+    /**
+     * Total number of days in this month
+     */
+    daysInMonth: number;
+}
+/**
+ * Week View Configuration
+ *
+ * Represents a week view with 7 days
+ */
+export interface CalendarWeek {
+    /**
+     * Start date of the week (usually Sunday)
+     */
+    startDate: Date;
+    /**
+     * End date of the week (usually Saturday)
+     */
+    endDate: Date;
+    /**
+     * All 7 days in the week
+     */
+    days: CalendarDay[];
+}

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

@@ -0,0 +1,140 @@
+/**
+ * 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

@@ -0,0 +1,101 @@
+/**
+ * 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

@@ -0,0 +1,39 @@
+/**
+ * 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

@@ -0,0 +1,70 @@
+/**
+ * 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;
+}