@onairos/react-native 3.1.18 → 3.2.1

package/src/utils/eventUtils.ts

@@ -1,303 +0,0 @@
-/**
- * Event utility functions for event management
- */
-
-/**
- * Generate a random alphanumeric event code
- * @param length - Length of the code (default: 6)
- * @returns Random event code
- */
-export const generateEventCode = (length: number = 6): string => {
-  const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
-  let result = '';
-  
-  for (let i = 0; i < length; i++) {
-    result += chars.charAt(Math.floor(Math.random() * chars.length));
-  }
-  
-  return result;
-};
-
-/**
- * Generate a smart event code based on the event title
- * @param title - Event title
- * @returns Smart event code
- */
-export const generateSmartEventCode = (title: string): string => {
-  if (!title.trim()) {
-    return generateEventCode();
-  }
-
-  // Clean the title and split into words
-  const words = title
-    .trim()
-    .toUpperCase()
-    .replace(/[^A-Z0-9\s]/g, '') // Remove special characters
-    .split(/\s+/)
-    .filter(word => word.length > 0);
-
-  if (words.length === 0) {
-    return generateEventCode();
-  }
-
-  let code = '';
-  
-  // Strategy 1: Take first 2 letters of each word (up to 3 words)
-  if (words.length >= 2) {
-    const significantWords = words.slice(0, 3);
-    code = significantWords
-      .map(word => word.substring(0, 2))
-      .join('');
-  } else {
-    // Strategy 2: Single word - take first 4 letters
-    code = words[0].substring(0, 4);
-  }
-
-  // Add current year's last 2 digits
-  const currentYear = new Date().getFullYear().toString().slice(-2);
-  code += currentYear;
-
-  // Ensure minimum length of 4 and maximum of 8
-  if (code.length < 4) {
-    code += generateEventCode(4 - code.length);
-  } else if (code.length > 8) {
-    code = code.substring(0, 8);
-  }
-
-  return code;
-};
-
-/**
- * Validate event code format
- * @param code - Event code to validate
- * @returns Object with validation result and error message
- */
-export const validateEventCode = (code: string): { isValid: boolean; error?: string } => {
-  if (!code || !code.trim()) {
-    return { isValid: false, error: 'Event code is required' };
-  }
-
-  const trimmedCode = code.trim().toUpperCase();
-
-  if (trimmedCode.length < 3) {
-    return { isValid: false, error: 'Event code must be at least 3 characters' };
-  }
-
-  if (trimmedCode.length > 10) {
-    return { isValid: false, error: 'Event code must be 10 characters or less' };
-  }
-
-  if (!/^[A-Z0-9]+$/.test(trimmedCode)) {
-    return { isValid: false, error: 'Event code must contain only letters and numbers' };
-  }
-
-  return { isValid: true };
-};
-
-/**
- * Format event date for display
- * @param dateString - Date string in YYYY-MM-DD format
- * @returns Formatted date string
- */
-export const formatEventDate = (dateString: string): string => {
-  try {
-    const date = new Date(dateString);
-    return date.toLocaleDateString('en-US', {
-      weekday: 'long',
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-    });
-  } catch (error) {
-    return dateString;
-  }
-};
-
-/**
- * Check if an event is happening today
- * @param eventDate - Event date string
- * @returns True if event is today
- */
-export const isEventToday = (eventDate: string): boolean => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    return (
-      today.getFullYear() === event.getFullYear() &&
-      today.getMonth() === event.getMonth() &&
-      today.getDate() === event.getDate()
-    );
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Check if an event is in the past
- * @param eventDate - Event date string
- * @returns True if event is in the past
- */
-export const isEventPast = (eventDate: string): boolean => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    // Set time to start of day for accurate comparison
-    today.setHours(0, 0, 0, 0);
-    event.setHours(0, 0, 0, 0);
-    
-    return event < today;
-  } catch (error) {
-    return false;
-  }
-};
-
-/**
- * Get event status based on date and active status
- * @param eventDate - Event date string
- * @param isActive - Whether event is active
- * @returns Event status string
- */
-export const getEventStatus = (eventDate: string, isActive: boolean): string => {
-  if (!isActive) {
-    return 'Inactive';
-  }
-  
-  if (isEventPast(eventDate)) {
-    return 'Past';
-  }
-  
-  if (isEventToday(eventDate)) {
-    return 'Today';
-  }
-  
-  return 'Upcoming';
-};
-
-/**
- * Calculate days until event
- * @param eventDate - Event date string
- * @returns Number of days until event (negative if past)
- */
-export const getDaysUntilEvent = (eventDate: string): number => {
-  try {
-    const today = new Date();
-    const event = new Date(eventDate);
-    
-    // Set time to start of day for accurate comparison
-    today.setHours(0, 0, 0, 0);
-    event.setHours(0, 0, 0, 0);
-    
-    const diffTime = event.getTime() - today.getTime();
-    const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24));
-    
-    return diffDays;
-  } catch (error) {
-    return 0;
-  }
-};
-
-/**
- * Sort events by date (upcoming first, then past events)
- * @param events - Array of events
- * @returns Sorted array of events
- */
-export const sortEventsByDate = <T extends { eventDate: string; isActive: boolean }>(events: T[]): T[] => {
-  return events.sort((a, b) => {
-    // Active events first
-    if (a.isActive && !b.isActive) return -1;
-    if (!a.isActive && b.isActive) return 1;
-    
-    // Then sort by date
-    const dateA = new Date(a.eventDate);
-    const dateB = new Date(b.eventDate);
-    
-    // Upcoming events first (ascending), then past events (descending)
-    const today = new Date();
-    const aIsPast = dateA < today;
-    const bIsPast = dateB < today;
-    
-    if (aIsPast && !bIsPast) return 1;
-    if (!aIsPast && bIsPast) return -1;
-    
-    if (aIsPast && bIsPast) {
-      return dateB.getTime() - dateA.getTime(); // Past events: most recent first
-    } else {
-      return dateA.getTime() - dateB.getTime(); // Upcoming events: soonest first
-    }
-  });
-};
-
-/**
- * Filter events by search query
- * @param events - Array of events
- * @param query - Search query
- * @returns Filtered array of events
- */
-export const filterEventsBySearch = <T extends { 
-  title: string; 
-  description: string; 
-  code: string; 
-  location?: string; 
-  organizer?: string;
-  tags?: string[];
-}>(events: T[], query: string): T[] => {
-  if (!query.trim()) {
-    return events;
-  }
-  
-  const searchTerm = query.toLowerCase().trim();
-  
-  return events.filter(event => 
-    event.title.toLowerCase().includes(searchTerm) ||
-    event.description.toLowerCase().includes(searchTerm) ||
-    event.code.toLowerCase().includes(searchTerm) ||
-    event.location?.toLowerCase().includes(searchTerm) ||
-    event.organizer?.toLowerCase().includes(searchTerm) ||
-    event.tags?.some(tag => tag.toLowerCase().includes(searchTerm))
-  );
-};
-
-/**
- * Get unique tags from events
- * @param events - Array of events
- * @returns Array of unique tags
- */
-export const getUniqueEventTags = <T extends { tags?: string[] }>(events: T[]): string[] => {
-  const allTags = events.flatMap(event => event.tags || []);
-  return Array.from(new Set(allTags)).sort();
-};
-
-/**
- * Calculate event statistics
- * @param events - Array of events
- * @returns Event statistics object
- */
-export const calculateEventStats = <T extends { 
-  isActive: boolean; 
-  attendeeCount: number; 
-  maxAttendees: number;
-  eventDate: string;
-}>(events: T[]) => {
-  const total = events.length;
-  const active = events.filter(e => e.isActive).length;
-  const inactive = total - active;
-  const totalAttendees = events.reduce((sum, e) => sum + e.attendeeCount, 0);
-  const totalCapacity = events.reduce((sum, e) => sum + e.maxAttendees, 0);
-  const upcoming = events.filter(e => e.isActive && !isEventPast(e.eventDate)).length;
-  const past = events.filter(e => isEventPast(e.eventDate)).length;
-  const today = events.filter(e => e.isActive && isEventToday(e.eventDate)).length;
-  
-  return {
-    total,
-    active,
-    inactive,
-    upcoming,
-    past,
-    today,
-    totalAttendees,
-    totalCapacity,
-    averageAttendance: totalCapacity > 0 ? Math.round((totalAttendees / totalCapacity) * 100) : 0,
-  };
-}; 

package/src/utils/haptics.ts

@@ -1,59 +0,0 @@
-import { Platform } from 'react-native';
-
-export enum HapticType {
-  LIGHT = 'light',
-  MEDIUM = 'medium',
-  HEAVY = 'heavy',
-  SUCCESS = 'success',
-  WARNING = 'warning',
-  ERROR = 'error',
-  BUTTON_PRESS = 'light', // Alias for button presses
-}
-
-export const triggerHaptic = (type: HapticType = HapticType.LIGHT) => {
-  if (Platform.OS === 'ios') {
-    try {
-      // Try to use react-native-haptic-feedback if available
-      const ReactNativeHapticFeedback = require('react-native-haptic-feedback');
-      
-      const options = {
-        enableVibrateFallback: true,
-        ignoreAndroidSystemSettings: false,
-      };
-
-      switch (type) {
-        case HapticType.LIGHT:
-          ReactNativeHapticFeedback.trigger('impactLight', options);
-          break;
-        case HapticType.MEDIUM:
-          ReactNativeHapticFeedback.trigger('impactMedium', options);
-          break;
-        case HapticType.HEAVY:
-          ReactNativeHapticFeedback.trigger('impactHeavy', options);
-          break;
-        case HapticType.SUCCESS:
-          ReactNativeHapticFeedback.trigger('notificationSuccess', options);
-          break;
-        case HapticType.WARNING:
-          ReactNativeHapticFeedback.trigger('notificationWarning', options);
-          break;
-        case HapticType.ERROR:
-          ReactNativeHapticFeedback.trigger('notificationError', options);
-          break;
-        default:
-          ReactNativeHapticFeedback.trigger('impactLight', options);
-      }
-    } catch (error) {
-      // Fallback to basic vibration if haptic feedback is not available
-      console.warn('Haptic feedback not available:', error);
-    }
-  } else if (Platform.OS === 'android') {
-    // Android fallback - basic vibration
-    try {
-      const { Vibration } = require('react-native');
-      Vibration.vibrate(50);
-    } catch (error) {
-      console.warn('Vibration not available:', error);
-    }
-  }
-};

package/src/utils/imagePreloader.ts

@@ -1,2 +0,0 @@
-// Image preloader utility for React Native
-export {};