@jmruthers/pace-core 0.6.10 → 0.6.11

package/src/utils/google-places/loadGoogleMapsScript.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Google Maps Script Loader Tests
  * @package @jmruthers/pace-core
- * @module Utils/GooglePlaces/__tests__
+ * @module Utils/GooglePlaces
  * @since 0.1.0
  */
 
@@ -33,8 +33,9 @@ describe('loadGoogleMapsScript', () => {
     (window as any).google = { maps: { places: {} } };
     const appendSpy = vi.spyOn(document.head, 'appendChild');
 
-    await expect(loadGoogleMapsScript('ready-key')).resolves.toBeUndefined();
-
+    const result = await loadGoogleMapsScript('ready-key');
+    expect(result.ok).toBe(true);
+    expect(result.data).toBeUndefined();
     expect(appendSpy).not.toHaveBeenCalled();
   });
 
@@ -50,7 +51,8 @@ describe('loadGoogleMapsScript', () => {
     (window as any).google = { maps: { places: {} } };
     scriptEl.onload?.(new Event('load'));
 
-    await expect(loadPromise).resolves.toBeUndefined();
+    const result = await loadPromise;
+    expect(result.ok).toBe(true);
   });
 
   it('reuses an existing script element', async () => {
@@ -65,11 +67,12 @@ describe('loadGoogleMapsScript', () => {
     (window as any).google = { maps: { places: {} } };
     existingScript.dispatchEvent(new Event('load'));
 
-    await expect(loadPromise).resolves.toBeUndefined();
+    const result = await loadPromise;
+    expect(result.ok).toBe(true);
     expect(appendSpy).not.toHaveBeenCalled();
   });
 
-  it('rejects when the script fails to load', async () => {
+  it('returns err when the script fails to load', async () => {
     const appendSpy = vi.spyOn(document.head, 'appendChild');
 
     const loadPromise = loadGoogleMapsScript('bad-key');
@@ -77,10 +80,12 @@ describe('loadGoogleMapsScript', () => {
 
     scriptEl.onerror?.(new Event('error'));
 
-    await expect(loadPromise).rejects.toThrow('Failed to load Google Maps script');
+    const result = await loadPromise;
+    expect(result.ok).toBe(false);
+    expect(result.error.message).toContain('Failed to load Google Maps script');
   });
 
-  it('rejects when an existing script never exposes Places', async () => {
+  it('returns err when an existing script never exposes Places', async () => {
     vi.useFakeTimers();
 
     const existingScript = document.createElement('script');
@@ -89,24 +94,21 @@ describe('loadGoogleMapsScript', () => {
     document.head.appendChild(existingScript);
 
     const loadPromise = loadGoogleMapsScript('new-key');
-    const assertion = expect(loadPromise).rejects.toThrow(
-      'Google Maps script loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console.'
-    );
 
     await vi.runAllTimersAsync();
-    await assertion;
+
+    const result = await loadPromise;
+    expect(result.ok).toBe(false);
+    expect(result.error.message).toContain('Places library not available');
 
     vi.useRealTimers();
   });
 
-  it('rejects when maps loads without the Places library', async () => {
+  it('returns err when maps loads without the Places library', async () => {
     vi.useFakeTimers();
 
     const appendSpy = vi.spyOn(document.head, 'appendChild');
     const loadPromise = loadGoogleMapsScript('api-key');
-    const assertion = expect(loadPromise).rejects.toThrow(
-      'Google Maps loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console and the "places" library is included in the script URL.'
-    );
     const scriptEl = appendSpy.mock.calls[0][0] as HTMLScriptElement;
 
     (window as any).google = { maps: {} };
@@ -114,26 +116,27 @@ describe('loadGoogleMapsScript', () => {
 
     await vi.runAllTimersAsync();
 
-    await assertion;
+    const result = await loadPromise;
+    expect(result.ok).toBe(false);
+    expect(result.error.message).toContain('Places library not available');
 
     vi.useRealTimers();
   });
 
-  it('rejects when google is not available after the script loads', async () => {
+  it('returns err when google is not available after the script loads', async () => {
     vi.useFakeTimers();
 
     const appendSpy = vi.spyOn(document.head, 'appendChild');
     const loadPromise = loadGoogleMapsScript('api-key');
-    const assertion = expect(loadPromise).rejects.toThrow(
-      'Google Maps script loaded but google object not available. Check your API key and network connection.'
-    );
     const scriptEl = appendSpy.mock.calls[0][0] as HTMLScriptElement;
 
     scriptEl.onload?.(new Event('load'));
 
     await vi.runAllTimersAsync();
 
-    await assertion;
+    const result = await loadPromise;
+    expect(result.ok).toBe(false);
+    expect(result.error.message).toContain('google object not available');
 
     vi.useRealTimers();
   });

package/src/utils/google-places/loadGoogleMapsScript.ts

@@ -8,122 +8,150 @@
  * This is required because the REST API doesn't support CORS from browsers.
  */
 
-// Type definitions for Google Maps (minimal, just what we need)
+// Extracted type definitions for Google Maps (minimal, just what we need)
+
+interface GooglePlacesLocationBiasCircle {
+  center: { latitude: number; longitude: number };
+  radius: number;
+}
+
+interface GooglePlacesAutocompleteSuggestionRequest {
+  input: string;
+  includedRegionCodes?: string[];
+  locationBias?: { circle?: GooglePlacesLocationBiasCircle };
+  includedPrimaryTypes?: string[];
+  languageCode?: string;
+}
+
+interface GooglePlacesTextMatch {
+  endOffset: number;
+  startOffset: number;
+}
+
+interface GooglePlacesStructuredFormat {
+  mainText: { text: string };
+  secondaryText: { text: string };
+}
+
+interface GooglePlacesPlacePrediction {
+  placeId: string;
+  text: { text: string; matches: GooglePlacesTextMatch[] };
+  structuredFormat?: GooglePlacesStructuredFormat;
+}
+
+interface GooglePlacesSuggestion {
+  placePrediction?: GooglePlacesPlacePrediction;
+}
+
+interface GooglePlacesAutocompleteSuggestion {
+  fetchAutocompleteSuggestions: (
+    request: GooglePlacesAutocompleteSuggestionRequest
+  ) => Promise<{ suggestions: GooglePlacesSuggestion[] }>;
+}
+
+interface GooglePlacesAutocompleteServiceRequest {
+  input: string;
+  componentRestrictions?: { country: string | string[] };
+  location?: { lat: () => number; lng: () => number };
+  radius?: number;
+  types?: string[];
+  language?: string;
+}
+
+interface GooglePlacesPrediction {
+  description: string;
+  place_id: string;
+  structured_formatting: { main_text: string; secondary_text: string };
+}
+
+interface GooglePlacesAutocompleteServiceInstance {
+  getPlacePredictions: (
+    request: GooglePlacesAutocompleteServiceRequest,
+    callback: (predictions: GooglePlacesPrediction[] | null, status: string) => void
+  ) => void;
+}
+
+interface GooglePlacesDetailsRequest {
+  placeId: string;
+  fields?: string[];
+}
+
+interface GooglePlacesAddressComponent {
+  long_name: string;
+  short_name: string;
+  types: string[];
+}
+
+interface GooglePlacesGeometry {
+  location?: { lat: () => number; lng: () => number };
+}
+
+interface GooglePlacesPlaceDetails {
+  place_id: string;
+  formatted_address?: string;
+  address_components?: GooglePlacesAddressComponent[];
+  geometry?: GooglePlacesGeometry;
+}
+
+interface GooglePlacesPlacesServiceInstance {
+  getDetails: (
+    request: GooglePlacesDetailsRequest,
+    callback: (place: GooglePlacesPlaceDetails | null, status: string) => void
+  ) => void;
+}
+
+interface GooglePlacesServiceStatus {
+  OK: string;
+  ZERO_RESULTS: string;
+  NOT_FOUND: string;
+  REQUEST_DENIED: string;
+  INVALID_REQUEST: string;
+  OVER_QUERY_LIMIT: string;
+}
+
+interface GoogleMapsPlaces {
+  AutocompleteSuggestion: GooglePlacesAutocompleteSuggestion;
+  AutocompleteService: new () => GooglePlacesAutocompleteServiceInstance;
+  PlacesService: new (element: HTMLElement) => GooglePlacesPlacesServiceInstance;
+  PlacesServiceStatus: GooglePlacesServiceStatus;
+}
+
+interface GoogleMapsLatLng {
+  lat: () => number;
+  lng: () => number;
+}
+
+interface GoogleMapsMaps {
+  places: GoogleMapsPlaces;
+  LatLng: new (lat: number, lng: number) => GoogleMapsLatLng;
+}
+
+interface GoogleMapsApi {
+  maps: GoogleMapsMaps;
+}
+
 declare global {
   interface Window {
-    google?: {
-      maps: {
-        places: {
-          // New AutocompleteSuggestion API (recommended)
-          AutocompleteSuggestion: {
-            fetchAutocompleteSuggestions: (
-              request: {
-                input: string;
-                includedRegionCodes?: string[];
-                locationBias?: {
-                  circle?: {
-                    center: { latitude: number; longitude: number };
-                    radius: number;
-                  };
-                };
-                includedPrimaryTypes?: string[];
-                languageCode?: string;
-              }
-            ) => Promise<{
-              suggestions: Array<{
-                placePrediction?: {
-                  placeId: string;
-                  text: {
-                    text: string;
-                    matches: Array<{
-                      endOffset: number;
-                      startOffset: number;
-                    }>;
-                  };
-                  structuredFormat?: {
-                    mainText: { text: string };
-                    secondaryText: { text: string };
-                  };
-                };
-              }>;
-            }>;
-          };
-          // Legacy AutocompleteService (deprecated but still works)
-          AutocompleteService: new () => {
-            getPlacePredictions: (
-              request: {
-                input: string;
-                componentRestrictions?: { country: string | string[] };
-                location?: { lat: () => number; lng: () => number };
-                radius?: number;
-                types?: string[];
-                language?: string;
-              },
-              callback: (
-                predictions: Array<{
-                  description: string;
-                  place_id: string;
-                  structured_formatting: {
-                    main_text: string;
-                    secondary_text: string;
-                  };
-                }> | null,
-                status: string
-              ) => void
-            ) => void;
-          };
-          PlacesService: new (element: HTMLElement) => {
-            getDetails: (
-              request: { placeId: string; fields?: string[] },
-              callback: (
-                place: {
-                  place_id: string;
-                  formatted_address?: string;
-                  address_components?: Array<{
-                    long_name: string;
-                    short_name: string;
-                    types: string[];
-                  }>;
-                  geometry?: {
-                    location?: {
-                      lat: () => number;
-                      lng: () => number;
-                    };
-                  };
-                } | null,
-                status: string
-              ) => void
-            ) => void;
-          };
-          PlacesServiceStatus: {
-            OK: string;
-            ZERO_RESULTS: string;
-            NOT_FOUND: string;
-            REQUEST_DENIED: string;
-            INVALID_REQUEST: string;
-            OVER_QUERY_LIMIT: string;
-          };
-        };
-        LatLng: new (lat: number, lng: number) => { lat: () => number; lng: () => number };
-      };
-    };
+    google?: GoogleMapsApi;
   }
 }
 
+import { ok, err, type ApiResult } from '../../types/api-result';
+
 /**
  * Load Google Maps JavaScript API script
  * @param apiKey - Google Places API key
  * @param libraries - Comma-separated list of libraries to load (default: 'places')
- * @returns Promise that resolves when the script is loaded
+ * @returns Promise that resolves to ApiResult<void>
  */
 export function loadGoogleMapsScript(
   apiKey: string,
   libraries: string = 'places'
-): Promise<void> {
-  return new Promise((resolve, reject) => {
+): Promise<ApiResult<void>> {
+  return new Promise((resolve) => {
     // Check if script is already loaded
     if (window.google && window.google.maps && window.google.maps.places) {
-      resolve();
+      resolve(ok(undefined));
       return;
     }
 
@@ -134,38 +162,35 @@ export function loadGoogleMapsScript(
     if (existingScript) {
       // If Google Maps is already loaded, resolve immediately
       if (window.google?.maps?.places) {
-        resolve();
+        resolve(ok(undefined));
         return;
       }
       
       // Wait for existing script to load
       const handleLoad = () => {
-        // Wait for the library to initialize with multiple retries
         let attempts = 0;
         const maxAttempts = 20; // 2 seconds total
         
         const checkPlaces = () => {
           if (window.google?.maps?.places) {
-            resolve();
+            resolve(ok(undefined));
           } else if (attempts < maxAttempts) {
             attempts++;
             setTimeout(checkPlaces, 100);
           } else {
-            reject(new Error('Google Maps script loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console.'));
+            resolve(err({ code: 'PLACES_UNAVAILABLE', message: 'Google Maps script loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console.' }));
           }
         };
         
         checkPlaces();
       };
       
-      // Check if script already loaded
       const scriptElement = existingScript as HTMLScriptElement;
       if (scriptElement.getAttribute('data-loaded') === 'true') {
         handleLoad();
         return;
       }
       
-      // Check if script is already complete (using type assertion for readyState which exists at runtime)
       const scriptWithReadyState = scriptElement as HTMLScriptElement & { readyState?: string };
       const scriptReadyState = scriptWithReadyState.readyState;
       if (scriptReadyState === 'complete' || scriptReadyState === 'loaded') {
@@ -175,7 +200,7 @@ export function loadGoogleMapsScript(
       
       existingScript.addEventListener('load', handleLoad, { once: true });
       existingScript.addEventListener('error', () => {
-        reject(new Error('Failed to load Google Maps script'));
+        resolve(err({ code: 'SCRIPT_LOAD_FAILED', message: 'Failed to load Google Maps script' }));
       }, { once: true });
       return;
     }
@@ -187,37 +212,33 @@ export function loadGoogleMapsScript(
     script.defer = true;
 
     script.onload = () => {
-      // Mark script as loaded
       script.setAttribute('data-loaded', 'true');
       
-      // Wait for the library to initialize with multiple retries
       let attempts = 0;
       const maxAttempts = 20; // 2 seconds total (20 * 100ms)
       
       const checkPlaces = () => {
         if (window.google?.maps?.places) {
-          resolve();
+          resolve(ok(undefined));
         } else if (attempts < maxAttempts) {
           attempts++;
           setTimeout(checkPlaces, 100);
         } else {
-          // Check if google.maps exists but places doesn't
           if (window.google?.maps && !window.google.maps.places) {
-            reject(new Error('Google Maps loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console and the "places" library is included in the script URL.'));
+            resolve(err({ code: 'PLACES_UNAVAILABLE', message: 'Google Maps loaded but Places library not available. Make sure the Places API is enabled in your Google Cloud Console and the "places" library is included in the script URL.' }));
           } else if (!window.google) {
-            reject(new Error('Google Maps script loaded but google object not available. Check your API key and network connection.'));
+            resolve(err({ code: 'GOOGLE_UNAVAILABLE', message: 'Google Maps script loaded but google object not available. Check your API key and network connection.' }));
           } else {
-            reject(new Error('Google Maps script loaded but Places library not available after multiple attempts. Make sure the Places API is enabled in your Google Cloud Console.'));
+            resolve(err({ code: 'PLACES_UNAVAILABLE', message: 'Google Maps script loaded but Places library not available after multiple attempts. Make sure the Places API is enabled in your Google Cloud Console.' }));
           }
         }
       };
       
-      // Start checking immediately, then retry if needed
       checkPlaces();
     };
 
     script.onerror = () => {
-      reject(new Error('Failed to load Google Maps script'));
+      resolve(err({ code: 'SCRIPT_LOAD_FAILED', message: 'Failed to load Google Maps script' }));
     };
 
     document.head.appendChild(script);

package/src/utils/{__tests__/index.unit.test.ts → index.unit.test.ts}

@@ -1,5 +1,5 @@
 import { describe, it, expect } from 'vitest';
-import * as Utils from '../index';
+import * as Utils from './index';
 
 describe('utils index exports', () => {
   describe('Core utilities', () => {

package/src/utils/{__tests__/lazyLoad.unit.test.tsx → lazyLoad.unit.test.tsx}

@@ -9,17 +9,18 @@ import React from 'react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { screen, waitFor, act } from '@testing-library/react';
 import '@testing-library/jest-dom';
-import { createLazyComponent, LazyDataTable } from '../dynamic/lazyLoad';
-import { renderWithProviders } from '../../__tests__/helpers/test-utils';
+import { createLazyComponent, LazyDataTable } from './dynamic/lazyLoad';
+import { renderWithProviders } from '../__tests__/helpers/test-utils';
 
-// Mock the DataTable component
-vi.mock('../../components/DataTable', () => ({
+// Mock the DataTable component (path must match dynamic import in utils/dynamic/lazyLoad.tsx -> src/components/DataTable)
+vi.mock('../components/DataTable', () => ({
   DataTable: vi.fn(() => <section data-testid="data-table">DataTable Component</section>)
 }));
 
-// Mock the LoadingSpinner component
-vi.mock('../../components/LoadingSpinner/LoadingSpinner', () => ({
-  LoadingSpinner: vi.fn(() => <p data-testid="loading-spinner">Loading...</p>)
+// Mock the LoadingSpinner component (path must match import in utils/dynamic/createLazyComponent.tsx)
+// Do not add data-testid here - createLazyComponent wraps it in <span data-testid="loading-spinner">
+vi.mock('../components/LoadingSpinner/LoadingSpinner', () => ({
+  LoadingSpinner: vi.fn(() => <p>Loading...</p>)
 }));
 
 describe('LazyLoad Utility', () => {
@@ -227,10 +228,9 @@ describe('LazyLoad Utility', () => {
       // Should show loading spinner initially
       expect(screen.getByTestId('loading-spinner')).toBeDefined();
 
-      // Wait for the DataTable to load
-      await waitFor(() => {
-        expect(screen.getByTestId('data-table')).toBeDefined();
-      });
+      // Wait for the DataTable to load (mocked module renders data-testid="data-table")
+      const tableEl = await screen.findByTestId('data-table', {}, { timeout: 3000 });
+      expect(tableEl).toBeInTheDocument();
     });
 
     it('should pass props to the DataTable component', async () => {
@@ -242,9 +242,8 @@ describe('LazyLoad Utility', () => {
 
       renderWithProviders(<LazyDataTable {...mockProps} />);
 
-      await waitFor(() => {
-        expect(screen.getByTestId('data-table')).toBeDefined();
-      });
+      const tableEl = await screen.findByTestId('data-table', {}, { timeout: 3000 });
+      expect(tableEl).toBeInTheDocument();
     });
 
     it('should render without errors', () => {

package/src/utils/location/location.test.ts

@@ -1,7 +1,7 @@
 /**
  * @file Location Utilities Tests
  * @package @jmruthers/pace-core
- * @module Utils/Location/__tests__
+ * @module Utils/Location
  * @since 0.1.0
  *
  * Comprehensive tests for location utility functions.

package/src/utils/{__tests__/logger.unit.test.ts → logger.unit.test.ts}

@@ -8,7 +8,7 @@
  */
 
 import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { Logger, LogLevel, logger, createLogger } from '../core/logger';
+import { Logger, LogLevel, logger, createLogger } from './core/logger';
 
 describe('Logger Utility', () => {
   let consoleDebugSpy: ReturnType<typeof vi.spyOn>;