@reservamos/browser-analytics 1.0.14 → 1.0.22-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reservamos/browser-analytics",
-  "version": "1.0.14",
+  "version": "1.0.22-alpha.0",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/reservamos/reservamos-browser-analytics.git"
@@ -61,7 +61,7 @@
   },
   "typings": "./dist/reservamos-browser-analytics.d.ts",
   "dependencies": {
-    "@fingerprintjs/fingerprintjs-pro-spa": "^1.3.2",
+    "@fingerprintjs/fingerprintjs-pro-spa": "^1.3.3",
     "mixpanel-browser": "^2.55.1",
     "zod": "^3.23.8"
   },

package/src/events/geolocationSelected/geolocationSelectedSchema.ts

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+
+const geolocationSelectedSchema = z.object({
+  "Selected City": z.string().min(1, 'Selected city is required'),
+  "Selected Country Code": z
+    .string()
+    .min(1, 'Selected Country Code is required'),
+});
+
+type GeolocationSelectedProps = z.infer<typeof geolocationSelectedSchema>;
+
+export type { GeolocationSelectedProps };
+export default geolocationSelectedSchema;

package/src/events/geolocationSelected/index.ts

@@ -0,0 +1,7 @@
+import type { GeolocationSelectedProps } from './geolocationSelectedSchema';
+import geolocationSelectedSchema from './geolocationSelectedSchema';
+import trackGeolocationSelected from './trackGeolocationSelected';
+
+export type { GeolocationSelectedProps };
+export { geolocationSelectedSchema };
+export default trackGeolocationSelected;

package/src/events/geolocationSelected/trackGeolocationSelected.ts

@@ -0,0 +1,21 @@
+import type { EventMetadata } from '@/types/eventData';
+import type { GeolocationSelectedProps } from './geolocationSelectedSchema';
+import mixpanelService from '@/services/mixpanel';
+import { trackEvent } from '@/track';
+
+const EVENT_NAME = 'Geolocation Selected';
+
+/**
+ * Tracks a Geolocation Selected event and updates the Mixpanel user profile.
+ * @param {GeolocationSelectedProps} eventData - The data associated with the geolocation selection.
+ * @param {EventMetadata} meta - Additional metadata to include in the event.
+ */
+function trackGeolocationSelected(
+  eventData: GeolocationSelectedProps,
+  meta: EventMetadata = {},
+): void {
+  trackEvent(EVENT_NAME, eventData, meta);
+  mixpanelService.setPeopleProperties(eventData);
+}
+
+export default trackGeolocationSelected;

package/src/index.ts

@@ -1,4 +1,5 @@
 import type { CustomEventProps } from '@/events/customEvent';
+import type { GeolocationSelectedProps } from '@/events/geolocationSelected';
 import type { InterestInHomeProps } from '@/events/interestInHome';
 import type { InterestInSearchProps } from '@/events/interestInSearch';
 import type { PassengersCreatedProps } from '@/events/passengersCreated';
@@ -17,6 +18,7 @@ import type { GetRecommendedSeatsSchemaProps } from '@/recommendations/getRecomm
 import type { GetRecommendedTripsProps } from '@/recommendations/getRecommendedTrips';
 import type { EventData, EventMetadata } from '@/types/eventData';
 import trackCustomEvent from '@/events/customEvent';
+import trackGeolocationSelected from '@/events/geolocationSelected';
 import identify from '@/events/identify';
 import trackInterestInHome from '@/events/interestInHome';
 import trackInterestInSearch from '@/events/interestInSearch';
@@ -72,6 +74,7 @@ const analytics = {
     pickedDeparture: trackPickedDeparture,
     customEvent: trackCustomEvent,
     purchaseCanceled: trackPurchaseCanceled,
+    geolocationSelected: trackGeolocationSelected,
   },
 };
 
@@ -95,6 +98,7 @@ export type {
   GetRecommendedTripsProps,
   CreateFrequentPassengersSchemaProps,
   DeleteFrequentPassengerProps,
+  GeolocationSelectedProps,
 };
 
 export default analytics;

package/src/init.ts

@@ -38,10 +38,8 @@ async function init(config: InitConfig) {
     identifyProxyUrl,
   } = config;
 
-  geolocationService.init();
   await mixpanelService.init(mixpanelToken, debug, mixpanelProxyUrl);
 
-  // Only mixpanel is required to be ready to dispatch the 'Tracker Ready' event
   try {
     await fingerprintService.initFingerprint(
       identificationKey,
@@ -51,6 +49,8 @@ async function init(config: InitConfig) {
     console.error('Error initializing identification service:', error);
   }
 
+  geolocationService.init();
+
   configService.setEnvironment(isSandbox ? 'sandbox' : 'prod');
   coreApi.setConfig(configService.getCoreAPIConfig());
 

package/src/services/fingerprint.ts

@@ -127,6 +127,10 @@ async function initFingerprint(
  */
 async function getFingerprint(cacheOnly = false): Promise<string> {
   if (!window.fingerprintConfig) {
+    if (cacheOnly) {
+      return '';
+    }
+
     throw new Error('Fingerprint configuration is not initialized.');
   }
 

package/src/services/geolocation.test.ts

@@ -0,0 +1,261 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+const trackCustomEventMock = vi.fn();
+const isTrackerReadyMock = vi.fn();
+const setPeoplePropertiesMock = vi.fn();
+
+vi.mock('@/events/customEvent', () => ({
+  default: trackCustomEventMock,
+}));
+
+vi.mock('@/init', () => ({
+  isTrackerReady: isTrackerReadyMock,
+}));
+
+vi.mock('@/services/mixpanel', () => ({
+  default: {
+    setPeopleProperties: setPeoplePropertiesMock,
+  },
+}));
+
+describe('geolocationService', () => {
+  let storage: Record<string, string>;
+
+  const expectedGeolocationOptions = {
+    enableHighAccuracy: true,
+    timeout: 10_000,
+    maximumAge: 0,
+  };
+
+  beforeEach(async () => {
+    storage = {};
+    vi.stubGlobal('localStorage', {
+      getItem: (key: string) => storage[key] ?? null,
+      setItem: (key: string, value: string) => {
+        storage[key] = value;
+      },
+      removeItem: (key: string) => {
+        storage = Object.fromEntries(
+          Object.entries(storage).filter(([entryKey]) => entryKey !== key),
+        );
+      },
+      clear: () => {
+        storage = {};
+      },
+    });
+
+    vi.resetModules();
+    trackCustomEventMock.mockReset();
+    isTrackerReadyMock.mockReset();
+    setPeoplePropertiesMock.mockReset();
+    isTrackerReadyMock.mockReturnValue(true);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  const mockGeolocationSuccess = (position: GeolocationPosition) => {
+    vi.stubGlobal('navigator', {
+      geolocation: {
+        getCurrentPosition: (
+          success: PositionCallback,
+          _error?: PositionErrorCallback,
+          options?: PositionOptions,
+        ) => {
+          expect(options).toEqual(expectedGeolocationOptions);
+          success(position);
+        },
+      },
+    });
+  };
+
+  const mockGeolocationError = (positionError: GeolocationPositionError) => {
+    vi.stubGlobal('navigator', {
+      geolocation: {
+        getCurrentPosition: (
+          _success: PositionCallback,
+          error?: PositionErrorCallback,
+          options?: PositionOptions,
+        ) => {
+          expect(options).toEqual(expectedGeolocationOptions);
+          error?.(positionError);
+        },
+      },
+    });
+  };
+
+  it('tracks and identifies granted geolocation with coordinates and accuracy', async () => {
+    const updatedAt = '2026-05-07T21:19:00.000Z';
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(updatedAt));
+
+    mockGeolocationSuccess({
+      coords: { latitude: 19.4326, longitude: -99.1332, accuracy: 12 },
+    } as GeolocationPosition);
+
+    const geolocationService = (await import('./geolocation')).default;
+    const coordinates = await geolocationService.init();
+
+    const expectedProperties = {
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'granted',
+      'Geolocation Accuracy': 12,
+      $latitude: 19.4326,
+      $longitude: -99.1332,
+    };
+
+    expect(coordinates).toEqual({ lat: 19.4326, long: -99.1332 });
+    expect(trackCustomEventMock).toHaveBeenCalledWith(
+      'Geolocation Requested',
+      expectedProperties,
+    );
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'granted',
+      $latitude: 19.4326,
+      $longitude: -99.1332,
+    });
+
+    vi.useRealTimers();
+  });
+
+  it('tracks and identifies denied geolocation when permission is rejected', async () => {
+    const updatedAt = '2026-05-07T21:19:00.000Z';
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(updatedAt));
+
+    mockGeolocationError({
+      code: 1,
+      PERMISSION_DENIED: 1,
+      POSITION_UNAVAILABLE: 2,
+      TIMEOUT: 3,
+    } as GeolocationPositionError);
+
+    const geolocationService = (await import('./geolocation')).default;
+    const coordinates = await geolocationService.init();
+
+    const expectedProperties = {
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'denied',
+      'Geolocation Error Code': 1,
+    };
+
+    expect(coordinates).toBeNull();
+    expect(trackCustomEventMock).toHaveBeenCalledWith(
+      'Geolocation Requested',
+      expectedProperties,
+    );
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'denied',
+    });
+
+    vi.useRealTimers();
+  });
+
+  it('tracks and identifies error geolocation when the request fails technically', async () => {
+    const updatedAt = '2026-05-07T21:19:00.000Z';
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date(updatedAt));
+
+    mockGeolocationError({
+      code: 3,
+      PERMISSION_DENIED: 1,
+      POSITION_UNAVAILABLE: 2,
+      TIMEOUT: 3,
+    } as GeolocationPositionError);
+
+    const geolocationService = (await import('./geolocation')).default;
+    await geolocationService.init();
+
+    const expectedProperties = {
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'error',
+      'Geolocation Error Code': 3,
+    };
+
+    expect(trackCustomEventMock).toHaveBeenCalledWith(
+      'Geolocation Requested',
+      expectedProperties,
+    );
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'error',
+    });
+
+    vi.useRealTimers();
+  });
+
+  it('tracks and identifies skipped_cache and restores coordinates from storage', async () => {
+    const updatedAt = '2026-05-07T21:19:00.000Z';
+    const permissionTimestamp = Date.now().toString();
+
+    localStorage.setItem('geolocationPermissionTimestamp', permissionTimestamp);
+    localStorage.setItem(
+      'geolocationCache',
+      JSON.stringify({
+        lat: 19.4326,
+        long: -99.1332,
+        updatedAt,
+        accuracy: 25,
+      }),
+    );
+
+    vi.stubGlobal('navigator', {
+      geolocation: {
+        getCurrentPosition: () => {
+          throw new Error('getCurrentPosition should not be called');
+        },
+      },
+    });
+
+    const geolocationService = (await import('./geolocation')).default;
+    const coordinates = await geolocationService.init();
+
+    const expectedProperties = {
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'skipped_cache',
+      'Geolocation Accuracy': 25,
+      $latitude: 19.4326,
+      $longitude: -99.1332,
+    };
+
+    expect(coordinates).toEqual({ lat: 19.4326, long: -99.1332 });
+    expect(trackCustomEventMock).toHaveBeenCalledWith(
+      'Geolocation Requested',
+      expectedProperties,
+    );
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Geolocation Updated At': updatedAt,
+      'Geolocation Status': 'skipped_cache',
+      $latitude: 19.4326,
+      $longitude: -99.1332,
+    });
+  });
+
+  it('ignores malformed geolocation cache entries', async () => {
+    const permissionTimestamp = Date.now().toString();
+    const expectedUpdatedAt = new Date(Number(permissionTimestamp)).toISOString();
+
+    localStorage.setItem('geolocationPermissionTimestamp', permissionTimestamp);
+    localStorage.setItem('geolocationCache', '{ invalid json');
+
+    vi.stubGlobal('navigator', {
+      geolocation: {
+        getCurrentPosition: () => {
+          throw new Error('getCurrentPosition should not be called');
+        },
+      },
+    });
+
+    const geolocationService = (await import('./geolocation')).default;
+    const coordinates = await geolocationService.init();
+
+    expect(coordinates).toBeNull();
+    expect(setPeoplePropertiesMock).toHaveBeenCalledWith({
+      'Geolocation Updated At': expectedUpdatedAt,
+      'Geolocation Status': 'skipped_cache',
+    });
+  });
+});