adserver-dashboard 1.0.0

package/client/src/lib/google-poi-api.ts

@@ -0,0 +1,305 @@
+declare global {
+  interface Window {
+    google: typeof google;
+  }
+}
+
+export interface PlaceResult {
+  id: string;
+  name: string;
+  coordinates: [number, number];
+  address?: string;
+  types?: string[];
+  rating?: number;
+  userRatingsTotal?: number;
+  placeId?: string;
+}
+
+export interface FetchNearbyPlacesOptions {
+  location: { lat: number; lng: number };
+  searchType: string;
+  radius?: number;
+  maxResults?: number;
+}
+
+const GOOGLE_PLACES_TYPE_MAP: Record<string, string> = {
+  rest_stop: 'rest_stop',
+  public_bath: 'spa',
+  rv_park: 'rv_park',
+  restaurant: 'restaurant',
+  cafe: 'cafe',
+  fast_food: 'meal_takeaway',
+  bar: 'bar',
+  hospital: 'hospital',
+  pharmacy: 'pharmacy',
+  doctor: 'doctor',
+  dentist: 'dentist',
+  school: 'school',
+  university: 'university',
+  library: 'library',
+  gas_station: 'gas_station',
+  car_wash: 'car_wash',
+  car_repair: 'car_repair',
+  parking: 'parking',
+  shopping_mall: 'shopping_mall',
+  supermarket: 'supermarket',
+  convenience_store: 'convenience_store',
+  clothing_store: 'clothing_store',
+  gym: 'gym',
+  spa: 'spa',
+  bank: 'bank',
+  atm: 'atm',
+  hotel: 'lodging',
+  motel: 'lodging',
+  campground: 'campground',
+  airport: 'airport',
+  train_station: 'train_station',
+  bus_station: 'bus_station',
+  transit_station: 'transit_station',
+  taxi_stand: 'taxi_stand',
+  park: 'park',
+  amusement_park: 'amusement_park',
+  zoo: 'zoo',
+  aquarium: 'aquarium',
+  museum: 'museum',
+  art_gallery: 'art_gallery',
+  movie_theater: 'movie_theater',
+  night_club: 'night_club',
+  bowling_alley: 'bowling_alley',
+  casino: 'casino',
+  stadium: 'stadium',
+  post_office: 'post_office',
+  laundry: 'laundry',
+  beauty_salon: 'beauty_salon',
+  hair_care: 'hair_care',
+  church: 'church',
+  mosque: 'mosque',
+  temple: 'hindu_temple',
+  synagogue: 'synagogue',
+};
+
+export function isGoogleMapsLoaded(): boolean {
+  return typeof window !== 'undefined' && 
+         typeof window.google !== 'undefined' && 
+         typeof window.google.maps !== 'undefined' &&
+         typeof window.google.maps.places !== 'undefined';
+}
+
+export async function loadGoogleMapsScript(apiKey: string): Promise<void> {
+  if (isGoogleMapsLoaded()) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    const existingScript = document.getElementById('google-maps-script');
+    if (existingScript) {
+      existingScript.addEventListener('load', () => resolve());
+      return;
+    }
+
+    const script = document.createElement('script');
+    script.id = 'google-maps-script';
+    script.src = `https://maps.googleapis.com/maps/api/js?key=${apiKey}&libraries=places`;
+    script.async = true;
+    script.defer = true;
+    script.onload = () => resolve();
+    script.onerror = () => reject(new Error('Failed to load Google Maps script'));
+    document.head.appendChild(script);
+  });
+}
+
+export async function fetchNearbyPlaces(
+  options: FetchNearbyPlacesOptions
+): Promise<PlaceResult[]> {
+  const { location, searchType, radius = 5000, maxResults = 20 } = options;
+
+  if (!isGoogleMapsLoaded()) {
+    console.warn('Google Maps Places API not loaded. Returning mock data.');
+    return generateMockPlaces(location, searchType, maxResults);
+  }
+
+  return new Promise((resolve, reject) => {
+    try {
+      const mapDiv = document.createElement('div');
+      const map = new window.google.maps.Map(mapDiv, {
+        center: location,
+        zoom: 15,
+      });
+
+      const service = new window.google.maps.places.PlacesService(map);
+      const placeType = GOOGLE_PLACES_TYPE_MAP[searchType] || searchType;
+
+      const request: google.maps.places.PlaceSearchRequest = {
+        location: new window.google.maps.LatLng(location.lat, location.lng),
+        radius,
+        type: placeType,
+      };
+
+      service.nearbySearch(request, (results, status) => {
+        if (status === window.google.maps.places.PlacesServiceStatus.OK && results) {
+          const places: PlaceResult[] = results.slice(0, maxResults).map((place, index) => ({
+            id: place.place_id || `place-${index}`,
+            name: place.name || 'Unknown Place',
+            coordinates: [
+              place.geometry?.location?.lng() || location.lng,
+              place.geometry?.location?.lat() || location.lat,
+            ] as [number, number],
+            address: place.vicinity || '',
+            types: place.types || [],
+            rating: place.rating,
+            userRatingsTotal: place.user_ratings_total,
+            placeId: place.place_id,
+          }));
+          resolve(places);
+        } else if (status === window.google.maps.places.PlacesServiceStatus.ZERO_RESULTS) {
+          resolve([]);
+        } else {
+          console.warn('Google Places API error:', status);
+          resolve(generateMockPlaces(location, searchType, maxResults));
+        }
+      });
+    } catch (error) {
+      console.error('Error fetching nearby places:', error);
+      resolve(generateMockPlaces(location, searchType, maxResults));
+    }
+  });
+}
+
+function generateMockPlaces(
+  location: { lat: number; lng: number },
+  searchType: string,
+  count: number
+): PlaceResult[] {
+  const places: PlaceResult[] = [];
+  const typeLabel = searchType.replace(/_/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+
+  for (let i = 0; i < Math.min(count, 10); i++) {
+    const offsetLng = (Math.random() - 0.5) * 0.02;
+    const offsetLat = (Math.random() - 0.5) * 0.02;
+    
+    places.push({
+      id: `mock-${searchType}-${i}`,
+      name: `${typeLabel} ${i + 1}`,
+      coordinates: [location.lng + offsetLng, location.lat + offsetLat],
+      address: `${Math.floor(Math.random() * 1000)} Example Street`,
+      types: [searchType],
+    });
+  }
+
+  return places;
+}
+
+export async function fetchMultiplePOITypes(
+  location: { lat: number; lng: number },
+  poiTypes: string[],
+  radius?: number
+): Promise<Map<string, PlaceResult[]>> {
+  const results = new Map<string, PlaceResult[]>();
+
+  const fetchPromises = poiTypes.map(async (type) => {
+    const places = await fetchNearbyPlaces({
+      location,
+      searchType: type,
+      radius,
+      maxResults: 10,
+    });
+    return { type, places };
+  });
+
+  const allResults = await Promise.all(fetchPromises);
+  
+  allResults.forEach(({ type, places }) => {
+    results.set(type, places);
+  });
+
+  return results;
+}
+
+export interface POICategoryResult {
+  label: string;
+  value: string;
+}
+
+export async function fetchPOICategories(options: {
+  location: { lat: number; lng: number };
+  radius?: number;
+}): Promise<POICategoryResult[]> {
+  const { location, radius = 5000 } = options;
+
+  if (!isGoogleMapsLoaded()) {
+    console.warn('Google Maps Places API not loaded. Returning default categories.');
+    return getDefaultPOICategories();
+  }
+
+  return new Promise((resolve) => {
+    try {
+      const mapDiv = document.createElement('div');
+      const map = new window.google.maps.Map(mapDiv, {
+        center: location,
+        zoom: 15,
+      });
+
+      const service = new window.google.maps.places.PlacesService(map);
+
+      const request: google.maps.places.PlaceSearchRequest = {
+        location: new window.google.maps.LatLng(location.lat, location.lng),
+        radius,
+      };
+
+      service.nearbySearch(request, (results, status) => {
+        if (status === window.google.maps.places.PlacesServiceStatus.OK && results) {
+          const typeSet = new Set<string>();
+          
+          results.forEach((place) => {
+            if (place.types) {
+              place.types.forEach((type) => {
+                if (!type.includes('establishment') && !type.includes('point_of_interest')) {
+                  typeSet.add(type);
+                }
+              });
+            }
+          });
+
+          const categories: POICategoryResult[] = Array.from(typeSet).map((type) => ({
+            label: formatTypeLabel(type),
+            value: type,
+          }));
+
+          resolve(categories.length > 0 ? categories : getDefaultPOICategories());
+        } else {
+          resolve(getDefaultPOICategories());
+        }
+      });
+    } catch (error) {
+      console.error('Error fetching POI categories:', error);
+      resolve(getDefaultPOICategories());
+    }
+  });
+}
+
+function formatTypeLabel(type: string): string {
+  return type
+    .split('_')
+    .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+    .join(' ');
+}
+
+function getDefaultPOICategories(): POICategoryResult[] {
+  return [
+    { label: 'Restaurant', value: 'restaurant' },
+    { label: 'Cafe', value: 'cafe' },
+    { label: 'Hospital', value: 'hospital' },
+    { label: 'Shopping Mall', value: 'shopping_mall' },
+    { label: 'School', value: 'school' },
+    { label: 'University', value: 'university' },
+    { label: 'Airport', value: 'airport' },
+    { label: 'Train Station', value: 'train_station' },
+    { label: 'Transit Station', value: 'transit_station' },
+    { label: 'Hotel', value: 'lodging' },
+    { label: 'Gas Station', value: 'gas_station' },
+    { label: 'Gym', value: 'gym' },
+    { label: 'Bank', value: 'bank' },
+    { label: 'Supermarket', value: 'supermarket' },
+    { label: 'Park', value: 'park' },
+  ];
+}

package/client/src/lib/i18n/__tests__/formatting.test.ts

@@ -0,0 +1,202 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+vi.mock('../index', () => ({
+  getCurrentLanguage: vi.fn(() => 'en-US'),
+}));
+
+import {
+  formatDate,
+  formatDateTime,
+  formatNumber,
+  formatCurrency,
+  formatPercent,
+  formatRelativeTime,
+  formatCompactNumber,
+  formatList,
+} from '../formatting';
+
+describe('i18n formatting', () => {
+  describe('formatDate', () => {
+    it('should format a Date object', () => {
+      const date = new Date(2024, 0, 15);
+      const result = formatDate(date);
+      expect(result).toContain('2024');
+      expect(result).toContain('15');
+    });
+
+    it('should format a date string', () => {
+      const result = formatDate('2024-01-15');
+      expect(result).toContain('2024');
+    });
+
+    it('should format a timestamp', () => {
+      const timestamp = new Date(2024, 0, 15).getTime();
+      const result = formatDate(timestamp);
+      expect(result).toContain('2024');
+    });
+
+    it('should accept custom options', () => {
+      const date = new Date(2024, 0, 15);
+      const result = formatDate(date, { weekday: 'long' });
+      expect(result).toContain('Monday');
+    });
+  });
+
+  describe('formatDateTime', () => {
+    it('should format date with time', () => {
+      const date = new Date(2024, 0, 15, 14, 30);
+      const result = formatDateTime(date);
+      expect(result).toContain('2024');
+    });
+
+    it('should handle date strings', () => {
+      const result = formatDateTime('2024-01-15T14:30:00');
+      expect(result).toContain('2024');
+    });
+
+    it('should handle timestamps', () => {
+      const timestamp = new Date(2024, 0, 15, 14, 30).getTime();
+      const result = formatDateTime(timestamp);
+      expect(result).toContain('2024');
+    });
+  });
+
+  describe('formatNumber', () => {
+    it('should format a number with locale', () => {
+      const result = formatNumber(1234567.89);
+      expect(result).toContain('1');
+      expect(result.length).toBeGreaterThan(5);
+    });
+
+    it('should accept custom options', () => {
+      const result = formatNumber(1234.5678, { maximumFractionDigits: 2 });
+      expect(result).toContain('1,234.57');
+    });
+  });
+
+  describe('formatCurrency', () => {
+    it('should format currency in USD by default', () => {
+      const result = formatCurrency(1234.56);
+      expect(result).toContain('$');
+      expect(result).toContain('1,234.56');
+    });
+
+    it('should format currency in specified currency', () => {
+      const result = formatCurrency(1234.56, 'EUR');
+      expect(result).toContain('1,234.56');
+    });
+  });
+
+  describe('formatPercent', () => {
+    it('should format a percentage', () => {
+      const result = formatPercent(75);
+      expect(result).toBe('75%');
+    });
+
+    it('should handle decimal percentages', () => {
+      const result = formatPercent(33.33);
+      expect(result).toContain('33');
+      expect(result).toContain('%');
+    });
+  });
+
+  describe('formatRelativeTime', () => {
+    it('should return a string for past date', () => {
+      const baseDate = new Date(2024, 5, 15, 12, 0, 0);
+      const pastDate = new Date(2024, 5, 10, 12, 0, 0);
+      const result = formatRelativeTime(pastDate, baseDate);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should return a string for future date', () => {
+      const baseDate = new Date(2024, 5, 15, 12, 0, 0);
+      const futureDate = new Date(2024, 5, 20, 12, 0, 0);
+      const result = formatRelativeTime(futureDate, baseDate);
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+
+    it('should handle Date objects', () => {
+      const result = formatRelativeTime(new Date());
+      expect(typeof result).toBe('string');
+    });
+
+    it('should handle date strings', () => {
+      const result = formatRelativeTime('2024-01-15');
+      expect(typeof result).toBe('string');
+    });
+
+    it('should handle timestamps', () => {
+      const result = formatRelativeTime(Date.now());
+      expect(typeof result).toBe('string');
+    });
+
+    it('should format seconds', () => {
+      const baseDate = new Date(2024, 5, 15, 12, 0, 30);
+      const pastDate = new Date(2024, 5, 15, 12, 0, 0);
+      const result = formatRelativeTime(pastDate, baseDate);
+      expect(result).toBe('30 seconds ago');
+    });
+
+    it('should format minutes', () => {
+      const baseDate = new Date(2024, 5, 15, 12, 30, 0);
+      const pastDate = new Date(2024, 5, 15, 12, 0, 0);
+      const result = formatRelativeTime(pastDate, baseDate);
+      expect(result).toBe('30 minutes ago');
+    });
+
+    it('should format hours', () => {
+      const baseDate = new Date(2024, 5, 15, 15, 0, 0);
+      const pastDate = new Date(2024, 5, 15, 12, 0, 0);
+      const result = formatRelativeTime(pastDate, baseDate);
+      expect(result).toBe('3 hours ago');
+    });
+
+    it('should format months', () => {
+      const baseDate = new Date(2024, 5, 15);
+      const pastDate = new Date(2024, 3, 15);
+      const result = formatRelativeTime(pastDate, baseDate);
+      expect(result).toBe('2 months ago');
+    });
+  });
+
+  describe('formatCompactNumber', () => {
+    it('should format large numbers compactly', () => {
+      const result = formatCompactNumber(1500000);
+      expect(result).toBe('1.5M');
+    });
+
+    it('should format thousands', () => {
+      const result = formatCompactNumber(2500);
+      expect(result).toBe('2.5K');
+    });
+
+    it('should format small numbers normally', () => {
+      const result = formatCompactNumber(123);
+      expect(result).toBe('123');
+    });
+  });
+
+  describe('formatList', () => {
+    it('should format a list with conjunction', () => {
+      const result = formatList(['apple', 'banana', 'cherry']);
+      expect(result).toBe('apple, banana, and cherry');
+    });
+
+    it('should format a list with disjunction', () => {
+      const result = formatList(['red', 'green', 'blue'], 'disjunction');
+      expect(result).toBe('red, green, or blue');
+    });
+
+    it('should handle single item list', () => {
+      const result = formatList(['apple']);
+      expect(result).toBe('apple');
+    });
+
+    it('should handle two item list', () => {
+      const result = formatList(['apple', 'banana']);
+      expect(result).toBe('apple and banana');
+    });
+  });
+});

package/client/src/lib/i18n/formatting.ts

@@ -0,0 +1,130 @@
+import { getCurrentLanguage } from './index';
+
+export const formatDate = (
+  date: Date | string | number,
+  options?: Intl.DateTimeFormatOptions
+): string => {
+  const locale = getCurrentLanguage();
+  const dateObj = typeof date === 'string' || typeof date === 'number' ? new Date(date) : date;
+  
+  const defaultOptions: Intl.DateTimeFormatOptions = {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    ...options,
+  };
+  
+  return new Intl.DateTimeFormat(locale, defaultOptions).format(dateObj);
+};
+
+export const formatDateTime = (
+  date: Date | string | number,
+  options?: Intl.DateTimeFormatOptions
+): string => {
+  const locale = getCurrentLanguage();
+  const dateObj = typeof date === 'string' || typeof date === 'number' ? new Date(date) : date;
+  
+  const defaultOptions: Intl.DateTimeFormatOptions = {
+    year: 'numeric',
+    month: 'short',
+    day: 'numeric',
+    hour: '2-digit',
+    minute: '2-digit',
+    ...options,
+  };
+  
+  return new Intl.DateTimeFormat(locale, defaultOptions).format(dateObj);
+};
+
+export const formatNumber = (
+  value: number,
+  options?: Intl.NumberFormatOptions
+): string => {
+  const locale = getCurrentLanguage();
+  return new Intl.NumberFormat(locale, options).format(value);
+};
+
+export const formatCurrency = (
+  value: number,
+  currency: string = 'USD',
+  options?: Intl.NumberFormatOptions
+): string => {
+  const locale = getCurrentLanguage();
+  
+  const defaultOptions: Intl.NumberFormatOptions = {
+    style: 'currency',
+    currency,
+    minimumFractionDigits: 2,
+    maximumFractionDigits: 2,
+    ...options,
+  };
+  
+  return new Intl.NumberFormat(locale, defaultOptions).format(value);
+};
+
+export const formatPercent = (
+  value: number,
+  options?: Intl.NumberFormatOptions
+): string => {
+  const locale = getCurrentLanguage();
+  
+  const defaultOptions: Intl.NumberFormatOptions = {
+    style: 'percent',
+    minimumFractionDigits: 0,
+    maximumFractionDigits: 2,
+    ...options,
+  };
+  
+  return new Intl.NumberFormat(locale, defaultOptions).format(value / 100);
+};
+
+export const formatRelativeTime = (
+  date: Date | string | number,
+  baseDate: Date = new Date()
+): string => {
+  const locale = getCurrentLanguage();
+  const dateObj = typeof date === 'string' || typeof date === 'number' ? new Date(date) : date;
+  
+  const diffInSeconds = Math.trunc((dateObj.getTime() - baseDate.getTime()) / 1000);
+  const diffInMinutes = Math.trunc(diffInSeconds / 60);
+  const diffInHours = Math.trunc(diffInMinutes / 60);
+  const diffInDays = Math.trunc(diffInHours / 24);
+  const diffInMonths = Math.trunc(diffInDays / 30);
+  const diffInYears = Math.trunc(diffInDays / 365);
+
+  const rtf = new Intl.RelativeTimeFormat(locale, { numeric: 'auto' });
+
+  if (Math.abs(diffInYears) >= 1) {
+    return rtf.format(diffInYears, 'year');
+  }
+  if (Math.abs(diffInMonths) >= 1) {
+    return rtf.format(diffInMonths, 'month');
+  }
+  if (Math.abs(diffInDays) >= 1) {
+    return rtf.format(diffInDays, 'day');
+  }
+  if (Math.abs(diffInHours) >= 1) {
+    return rtf.format(diffInHours, 'hour');
+  }
+  if (Math.abs(diffInMinutes) >= 1) {
+    return rtf.format(diffInMinutes, 'minute');
+  }
+  return rtf.format(diffInSeconds, 'second');
+};
+
+export const formatCompactNumber = (value: number): string => {
+  const locale = getCurrentLanguage();
+  
+  return new Intl.NumberFormat(locale, {
+    notation: 'compact',
+    maximumFractionDigits: 1,
+  }).format(value);
+};
+
+export const formatList = (
+  items: string[],
+  type: 'conjunction' | 'disjunction' = 'conjunction'
+): string => {
+  const locale = getCurrentLanguage();
+  return new Intl.ListFormat(locale, { style: 'long', type }).format(items);
+};

package/client/src/lib/i18n/index.ts

@@ -0,0 +1,8 @@
+export { 
+  useTranslation, 
+  supportedLanguages, 
+  getLanguageDirection, 
+  getCurrentLanguage, 
+  changeLanguage,
+  type SupportedLanguage 
+} from '../i18n-compat';