@onairos/react-native 3.1.11 → 3.1.13

package/src/utils/eventUtils.ts

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

@@ -0,0 +1,59 @@
+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

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