@bglocation/capacitor 1.1.0

package/dist/esm/web.test.js

@@ -0,0 +1,940 @@
+import { beforeEach, afterEach, describe, expect, it, vi } from 'vitest';
+import { BackgroundLocationWeb } from './web';
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+const DEFAULT_CONFIG = {
+    distanceFilter: 15,
+    desiredAccuracy: 'high',
+    locationUpdateInterval: 5000,
+    fastestLocationUpdateInterval: 2000,
+    heartbeatInterval: 15,
+};
+const HTTP_CONFIG = {
+    ...DEFAULT_CONFIG,
+    http: {
+        url: 'https://api.example.com/location',
+        headers: { Authorization: 'Bearer test' },
+    },
+};
+function makeGeolocationPosition(overrides = {}, timestamp = 1700000000000) {
+    return {
+        coords: {
+            latitude: 52.2297,
+            longitude: 21.0122,
+            accuracy: 10,
+            speed: 1.5,
+            heading: 90,
+            altitude: 100,
+            altitudeAccuracy: 5,
+            toJSON() { return this; },
+            ...overrides,
+        },
+        timestamp,
+        toJSON() { return this; },
+    };
+}
+// ---------------------------------------------------------------------------
+// Mock navigator.geolocation
+// ---------------------------------------------------------------------------
+let watchCallback = null;
+let getCurrentSuccessCallback = null;
+let getCurrentErrorCallback = null;
+const mockGeolocation = {
+    watchPosition: vi.fn((success, _error, _options) => {
+        watchCallback = success;
+        return 42; // watchId
+    }),
+    clearWatch: vi.fn(),
+    getCurrentPosition: vi.fn((success, error, _options) => {
+        getCurrentSuccessCallback = success;
+        getCurrentErrorCallback = error ?? null;
+    }),
+};
+const mockPermissions = {
+    query: vi.fn().mockResolvedValue({ state: 'granted' }),
+};
+vi.stubGlobal('navigator', { geolocation: mockGeolocation, permissions: mockPermissions });
+// ---------------------------------------------------------------------------
+// Mock fetch for HTTP tests
+// ---------------------------------------------------------------------------
+const mockFetch = vi.fn();
+vi.stubGlobal('fetch', mockFetch);
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+describe('BackgroundLocationWeb', () => {
+    let plugin;
+    beforeEach(() => {
+        vi.useFakeTimers();
+        plugin = new BackgroundLocationWeb();
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+        vi.useRealTimers();
+        watchCallback = null;
+        getCurrentSuccessCallback = null;
+        getCurrentErrorCallback = null;
+    });
+    // -----------------------------------------------------------------------
+    // configure()
+    // -----------------------------------------------------------------------
+    describe('configure', () => {
+        it('should store config without calling geolocation', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            expect(mockGeolocation.watchPosition).not.toHaveBeenCalled();
+        });
+        it('should allow reconfiguration', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.configure({ ...DEFAULT_CONFIG, distanceFilter: 30 });
+            const state = await plugin.getState();
+            expect(state.tracking).toBe(false);
+        });
+        it('should accept notification config without error', async () => {
+            await expect(plugin.configure({
+                ...DEFAULT_CONFIG,
+                notification: { title: 'My App', text: 'Tracking active' },
+            })).resolves.toEqual({ licenseMode: 'full', distanceFilterMode: 'fixed' });
+        });
+        it('should always return licenseMode full on web', async () => {
+            const result = await plugin.configure(DEFAULT_CONFIG);
+            expect(result).toEqual({ licenseMode: 'full', distanceFilterMode: 'fixed' });
+        });
+        it('should return distanceFilterMode auto when distanceFilter is auto', async () => {
+            const result = await plugin.configure({ ...DEFAULT_CONFIG, distanceFilter: 'auto' });
+            expect(result).toEqual({ licenseMode: 'full', distanceFilterMode: 'auto' });
+        });
+        it('should emit debug warning when distanceFilter is auto', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure({ ...DEFAULT_CONFIG, distanceFilter: 'auto', debug: true });
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('distanceFilter=auto ignored on Web'),
+            }));
+        });
+        it('should accept autoDistanceFilter config with auto mode', async () => {
+            const result = await plugin.configure({
+                ...DEFAULT_CONFIG,
+                distanceFilter: 'auto',
+                autoDistanceFilter: { targetInterval: 5, minDistance: 20, maxDistance: 300 },
+            });
+            expect(result).toEqual({ licenseMode: 'full', distanceFilterMode: 'auto' });
+        });
+        it('should accept minimal (empty) config using defaults', async () => {
+            const result = await plugin.configure({});
+            expect(result).toEqual({ licenseMode: 'full', distanceFilterMode: 'fixed' });
+        });
+        it('should accept partial config with only distanceFilter', async () => {
+            const result = await plugin.configure({ distanceFilter: 50 });
+            expect(result).toEqual({ licenseMode: 'full', distanceFilterMode: 'fixed' });
+        });
+        it('should work with partial config through full lifecycle', async () => {
+            await plugin.configure({ heartbeatInterval: 5 });
+            const startState = await plugin.start();
+            expect(startState.tracking).toBe(true);
+            // Heartbeat should work with the configured 5s interval
+            vi.advanceTimersByTime(5_000);
+            expect(mockGeolocation.getCurrentPosition).toHaveBeenCalledOnce();
+            const stopState = await plugin.stop();
+            expect(stopState.tracking).toBe(false);
+        });
+        it('should default desiredAccuracy to high when not provided', async () => {
+            await plugin.configure({ distanceFilter: 50 });
+            await plugin.start();
+            const options = mockGeolocation.watchPosition.mock.calls[0][2];
+            expect(options.enableHighAccuracy).toBe(true);
+        });
+        it('should default heartbeatInterval to 15s when not provided', async () => {
+            await plugin.configure({});
+            await plugin.start();
+            // Heartbeat should NOT fire at 5s
+            vi.advanceTimersByTime(5_000);
+            expect(mockGeolocation.getCurrentPosition).not.toHaveBeenCalled();
+            // Heartbeat SHOULD fire at 15s
+            vi.advanceTimersByTime(10_000);
+            expect(mockGeolocation.getCurrentPosition).toHaveBeenCalledOnce();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // start()
+    // -----------------------------------------------------------------------
+    describe('start', () => {
+        it('should throw if called before configure()', async () => {
+            await expect(plugin.start()).rejects.toThrow('Plugin not configured. Call configure() first.');
+        });
+        it('should start watching position', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            const state = await plugin.start();
+            expect(state).toEqual({ enabled: true, tracking: true });
+            expect(mockGeolocation.watchPosition).toHaveBeenCalledOnce();
+        });
+        it('should pass enableHighAccuracy true for "high" accuracy', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, desiredAccuracy: 'high' });
+            await plugin.start();
+            const options = mockGeolocation.watchPosition.mock.calls[0][2];
+            expect(options.enableHighAccuracy).toBe(true);
+        });
+        it('should pass enableHighAccuracy false for "balanced" accuracy', async () => {
+            await plugin.configure({
+                ...DEFAULT_CONFIG,
+                desiredAccuracy: 'balanced',
+            });
+            await plugin.start();
+            const options = mockGeolocation.watchPosition.mock.calls[0][2];
+            expect(options.enableHighAccuracy).toBe(false);
+        });
+        it('should emit onLocation when watch position fires', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onLocation', listener);
+            const position = makeGeolocationPosition({ latitude: 50.0, longitude: 20.0 });
+            watchCallback(position);
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ latitude: 50.0, longitude: 20.0 }));
+        });
+        it('should start heartbeat timer', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, heartbeatInterval: 10 });
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHeartbeat', listener);
+            // Advance past the heartbeat interval so the setInterval fires
+            vi.advanceTimersByTime(10_000);
+            // The heartbeat called getCurrentPosition — satisfy it with a position
+            expect(getCurrentSuccessCallback).not.toBeNull();
+            const position = makeGeolocationPosition();
+            getCurrentSuccessCallback(position);
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                location: expect.objectContaining({ latitude: 52.2297 }),
+            }));
+        });
+        it('should emit heartbeat with null location when GPS fails', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, heartbeatInterval: 10 });
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHeartbeat', listener);
+            vi.advanceTimersByTime(10_000);
+            // Simulate GPS error — call the error callback
+            expect(getCurrentErrorCallback).not.toBeNull();
+            getCurrentErrorCallback({
+                code: 1,
+                message: 'Position unavailable',
+                PERMISSION_DENIED: 1,
+                POSITION_UNAVAILABLE: 2,
+                TIMEOUT: 3,
+            });
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                location: null,
+                timestamp: expect.any(Number),
+            }));
+        });
+    });
+    // -----------------------------------------------------------------------
+    // stop()
+    // -----------------------------------------------------------------------
+    describe('stop', () => {
+        it('should return stopped state with permission still enabled', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            const state = await plugin.stop();
+            expect(state).toEqual({ enabled: true, tracking: false });
+        });
+        it('should clear the geolocation watch', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            await plugin.stop();
+            expect(mockGeolocation.clearWatch).toHaveBeenCalledWith(42);
+        });
+        it('should be safe to call stop when not started', async () => {
+            const state = await plugin.stop();
+            expect(state).toEqual({ enabled: true, tracking: false });
+            expect(mockGeolocation.clearWatch).not.toHaveBeenCalled();
+        });
+        it('should stop heartbeat timer', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, heartbeatInterval: 5 });
+            await plugin.start();
+            await plugin.stop();
+            // Advance time past heartbeat interval — no heartbeat should fire
+            vi.advanceTimersByTime(10_000);
+            expect(mockGeolocation.getCurrentPosition).not.toHaveBeenCalled();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // getState()
+    // -----------------------------------------------------------------------
+    describe('getState', () => {
+        it('should return not tracking initially', async () => {
+            const state = await plugin.getState();
+            expect(state).toEqual({ enabled: true, tracking: false });
+        });
+        it('should return tracking after start', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            const state = await plugin.getState();
+            expect(state).toEqual({ enabled: true, tracking: true });
+        });
+        it('should return not tracking after stop', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            await plugin.stop();
+            const state = await plugin.getState();
+            expect(state).toEqual({ enabled: true, tracking: false });
+        });
+    });
+    // -----------------------------------------------------------------------
+    // getCurrentPosition()
+    // -----------------------------------------------------------------------
+    describe('getCurrentPosition', () => {
+        it('should resolve with mapped location on success', async () => {
+            const position = makeGeolocationPosition({
+                latitude: 48.8566,
+                longitude: 2.3522,
+            });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const result = await promise;
+            expect(result).toEqual(expect.objectContaining({ latitude: 48.8566, longitude: 2.3522 }));
+        });
+        it('should reject with Error on geolocation failure', async () => {
+            const promise = plugin.getCurrentPosition();
+            getCurrentErrorCallback({
+                code: 1,
+                message: 'User denied Geolocation',
+                PERMISSION_DENIED: 1,
+                POSITION_UNAVAILABLE: 2,
+                TIMEOUT: 3,
+            });
+            await expect(promise).rejects.toThrow('User denied Geolocation');
+        });
+        it('should use custom timeout from options', async () => {
+            plugin.getCurrentPosition({ timeout: 5000 });
+            const options = mockGeolocation.getCurrentPosition.mock.calls[0][2];
+            expect(options.timeout).toBe(5000);
+        });
+        it('should default timeout to 20000 when no options provided', async () => {
+            plugin.getCurrentPosition();
+            const options = mockGeolocation.getCurrentPosition.mock.calls[0][2];
+            expect(options.timeout).toBe(20000);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // geolocationToLocation (via public methods)
+    // -----------------------------------------------------------------------
+    describe('location mapping', () => {
+        it('should map all coordinate fields correctly', async () => {
+            const position = makeGeolocationPosition({
+                latitude: 52.0,
+                longitude: 21.0,
+                accuracy: 5,
+                speed: 3.0,
+                heading: 180,
+                altitude: 200,
+            });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location).toEqual({
+                latitude: 52.0,
+                longitude: 21.0,
+                accuracy: 5,
+                speed: 3.0,
+                heading: 180,
+                altitude: 200,
+                timestamp: 1700000000000,
+                isMoving: true,
+                isMock: false,
+            });
+        });
+        it('should default speed to 0 when null', async () => {
+            const position = makeGeolocationPosition({ speed: null });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.speed).toBe(0);
+            expect(location.isMoving).toBe(false);
+        });
+        it('should default heading to -1 when null', async () => {
+            const position = makeGeolocationPosition({ heading: null });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.heading).toBe(-1);
+        });
+        it('should default altitude to 0 when null', async () => {
+            const position = makeGeolocationPosition({ altitude: null });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.altitude).toBe(0);
+        });
+        it('should set isMoving=false when speed is exactly 0.5', async () => {
+            const position = makeGeolocationPosition({ speed: 0.5 });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.isMoving).toBe(false);
+        });
+        it('should set isMoving=true when speed is above 0.5', async () => {
+            const position = makeGeolocationPosition({ speed: 0.51 });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.isMoving).toBe(true);
+        });
+        it('should set isMoving=false when speed is 0', async () => {
+            const position = makeGeolocationPosition({ speed: 0 });
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.isMoving).toBe(false);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // removeAllListeners()
+    // -----------------------------------------------------------------------
+    describe('removeAllListeners', () => {
+        it('should stop tracking and clear watch', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            await plugin.removeAllListeners();
+            expect(mockGeolocation.clearWatch).toHaveBeenCalledWith(42);
+            const state = await plugin.getState();
+            expect(state.tracking).toBe(false);
+        });
+        it('should stop heartbeat timer', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, heartbeatInterval: 5 });
+            await plugin.start();
+            await plugin.removeAllListeners();
+            vi.advanceTimersByTime(10_000);
+            expect(mockGeolocation.getCurrentPosition).not.toHaveBeenCalled();
+        });
+        it('should be safe to call when not started', async () => {
+            await expect(plugin.removeAllListeners()).resolves.toBeUndefined();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Full lifecycle
+    // -----------------------------------------------------------------------
+    describe('lifecycle', () => {
+        it('should support configure → start → stop → start cycle', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            const state1 = await plugin.start();
+            expect(state1.tracking).toBe(true);
+            const state2 = await plugin.stop();
+            expect(state2.tracking).toBe(false);
+            const state3 = await plugin.start();
+            expect(state3.tracking).toBe(true);
+            expect(mockGeolocation.watchPosition).toHaveBeenCalledTimes(2);
+        });
+    });
+    // -----------------------------------------------------------------------
+    // HTTP (native-emulated via fetch)
+    // -----------------------------------------------------------------------
+    describe('http', () => {
+        it('should not send fetch when http config is not set', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            expect(mockFetch).not.toHaveBeenCalled();
+        });
+        it('should POST location to configured URL on each location event', async () => {
+            mockFetch.mockResolvedValue({
+                status: 201,
+                ok: true,
+                text: () => Promise.resolve('{"ok":true}'),
+            });
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition({ latitude: 50.0, longitude: 20.0 });
+            watchCallback(position);
+            expect(mockFetch).toHaveBeenCalledWith('https://api.example.com/location', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    Authorization: 'Bearer test',
+                }),
+            }));
+            const callBody = JSON.parse(mockFetch.mock.calls[0][1].body);
+            expect(callBody.location.latitude).toBe(50.0);
+            expect(callBody.location.longitude).toBe(20.0);
+        });
+        it('should emit onHttp with success on 2xx response', async () => {
+            mockFetch.mockResolvedValue({
+                status: 201,
+                ok: true,
+                text: () => Promise.resolve('{"id":123}'),
+            });
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHttp', listener);
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            // Wait for async fetch + response
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    statusCode: 201,
+                    success: true,
+                    responseText: '{"id":123}',
+                }));
+            });
+        });
+        it('should emit onHttp with error on network failure', async () => {
+            mockFetch.mockRejectedValue(new Error('Network error'));
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHttp', listener);
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    statusCode: 0,
+                    success: false,
+                    error: 'Network error',
+                }));
+            });
+        });
+        it('should emit onHttp with failure on 4xx response', async () => {
+            mockFetch.mockResolvedValue({
+                status: 400,
+                ok: false,
+                text: () => Promise.resolve('Bad Request'),
+            });
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHttp', listener);
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    statusCode: 400,
+                    success: false,
+                    responseText: 'Bad Request',
+                }));
+            });
+        });
+        it('should stop sending HTTP after stop()', async () => {
+            mockFetch.mockResolvedValue({
+                status: 200,
+                ok: true,
+                text: () => Promise.resolve(''),
+            });
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+            await plugin.stop();
+            // After stop, new watchCallbacks shouldn't fire, but let's verify
+            // fetch count didn't increase
+            expect(mockFetch).toHaveBeenCalledTimes(1);
+        });
+        it('should include bufferedCount: 0 in onHttp success event', async () => {
+            mockFetch.mockResolvedValue({
+                status: 200,
+                ok: true,
+                text: () => Promise.resolve('OK'),
+            });
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHttp', listener);
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    success: true,
+                    bufferedCount: 0,
+                }));
+            });
+        });
+        it('should include bufferedCount: 0 in onHttp error event', async () => {
+            mockFetch.mockRejectedValue(new Error('offline'));
+            await plugin.configure(HTTP_CONFIG);
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHttp', listener);
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    success: false,
+                    bufferedCount: 0,
+                }));
+            });
+        });
+        it('should accept http config with buffer option', async () => {
+            await expect(plugin.configure({
+                ...DEFAULT_CONFIG,
+                http: {
+                    url: 'https://api.example.com/loc',
+                    buffer: { maxSize: 500 },
+                },
+            })).resolves.toEqual({ licenseMode: 'full', distanceFilterMode: 'fixed' });
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Debug mode (onDebug)
+    // -----------------------------------------------------------------------
+    describe('debug mode', () => {
+        const DEBUG_CONFIG = { ...DEFAULT_CONFIG, debug: true };
+        const DEBUG_HTTP_CONFIG = { ...HTTP_CONFIG, debug: true };
+        it('should not emit onDebug when debug is false', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.advanceTimersByTimeAsync(0);
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('should emit onDebug CONFIGURE on configure()', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('CONFIGURE'),
+                timestamp: expect.any(Number),
+            }));
+        });
+        it('should emit onDebug START on start()', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('START'),
+            }));
+        });
+        it('should emit onDebug STOP on stop()', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            await plugin.stop();
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('STOP'),
+            }));
+        });
+        it('should emit onDebug LOCATION when location fires', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('LOCATION #1'),
+            }));
+        });
+        it('should emit onDebug HEARTBEAT on heartbeat tick', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            vi.advanceTimersByTime(15_000);
+            getCurrentSuccessCallback(makeGeolocationPosition());
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('HEARTBEAT #1'),
+            }));
+        });
+        it('should emit onDebug HTTP OK on successful HTTP', async () => {
+            mockFetch.mockResolvedValue({
+                status: 200,
+                ok: true,
+                text: () => Promise.resolve(''),
+            });
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_HTTP_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    message: expect.stringContaining('HTTP OK'),
+                }));
+            });
+        });
+        it('should emit onDebug HTTP ERROR on failed HTTP', async () => {
+            mockFetch.mockRejectedValue(new Error('Network error'));
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_HTTP_CONFIG);
+            await plugin.start();
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            await vi.waitFor(() => {
+                expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                    message: expect.stringContaining('HTTP ERROR'),
+                }));
+            });
+        });
+        it('should increment location counter across multiple events', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            watchCallback(makeGeolocationPosition());
+            watchCallback(makeGeolocationPosition());
+            watchCallback(makeGeolocationPosition());
+            const locationMessages = listener.mock.calls
+                .map((c) => c[0].message)
+                .filter((m) => m.startsWith('LOCATION'));
+            expect(locationMessages).toEqual([
+                expect.stringContaining('LOCATION #1'),
+                expect.stringContaining('LOCATION #2'),
+                expect.stringContaining('LOCATION #3'),
+            ]);
+        });
+        it('should reset counters on start()', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_CONFIG);
+            await plugin.start();
+            watchCallback(makeGeolocationPosition());
+            watchCallback(makeGeolocationPosition());
+            await plugin.stop();
+            await plugin.start();
+            watchCallback(makeGeolocationPosition());
+            const locationMessages = listener.mock.calls
+                .map((c) => c[0].message)
+                .filter((m) => m.startsWith('LOCATION'));
+            // After restart, counter should be back to #1
+            expect(locationMessages[locationMessages.length - 1]).toContain('LOCATION #1');
+        });
+        it('should include counters in STOP message', async () => {
+            mockFetch.mockResolvedValue({
+                status: 200,
+                ok: true,
+                text: () => Promise.resolve(''),
+            });
+            const listener = vi.fn();
+            await plugin.addListener('onDebug', listener);
+            await plugin.configure(DEBUG_HTTP_CONFIG);
+            await plugin.start();
+            watchCallback(makeGeolocationPosition());
+            // Wait for HTTP to complete and debug event to fire
+            await vi.waitFor(() => {
+                const httpOkMessages = listener.mock.calls
+                    .map((c) => c[0].message)
+                    .filter((m) => m.startsWith('HTTP OK'));
+                expect(httpOkMessages.length).toBe(1);
+            });
+            await plugin.stop();
+            const stopMessage = listener.mock.calls
+                .map((c) => c[0].message)
+                .find((m) => m.startsWith('STOP'));
+            expect(stopMessage).toContain('locations=1');
+            expect(stopMessage).toContain('http_ok=1');
+        });
+    });
+    // -----------------------------------------------------------------------
+    // checkBatteryOptimization() — B.1
+    // -----------------------------------------------------------------------
+    describe('checkBatteryOptimization()', () => {
+        it('should return no-op result on Web (always safe)', async () => {
+            const result = await plugin.checkBatteryOptimization();
+            expect(result.isIgnoringOptimizations).toBe(true);
+            expect(result.manufacturer).toBe('');
+            expect(result.helpUrl).toBe('');
+            expect(result.message).toContain('not applicable');
+        });
+    });
+    // -----------------------------------------------------------------------
+    // requestBatteryOptimization() — B.1
+    // -----------------------------------------------------------------------
+    describe('requestBatteryOptimization()', () => {
+        it('should return same no-op result as checkBatteryOptimization()', async () => {
+            const result = await plugin.requestBatteryOptimization();
+            expect(result.isIgnoringOptimizations).toBe(true);
+            expect(result.manufacturer).toBe('');
+            expect(result.helpUrl).toBe('');
+        });
+    });
+    // -----------------------------------------------------------------------
+    // isMock field in Location — C.3
+    // -----------------------------------------------------------------------
+    describe('isMock field (C.3)', () => {
+        it('should always include isMock: false in location from getCurrentPosition()', async () => {
+            const position = makeGeolocationPosition();
+            const promise = plugin.getCurrentPosition();
+            getCurrentSuccessCallback(position);
+            const location = await promise;
+            expect(location.isMock).toBe(false);
+        });
+        it('should always include isMock: false in onLocation event', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            const listener = vi.fn();
+            await plugin.addListener('onLocation', listener);
+            await plugin.start();
+            watchCallback(makeGeolocationPosition());
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ isMock: false }));
+        });
+        it('should always include isMock: false in onHeartbeat location', async () => {
+            await plugin.configure({ ...DEFAULT_CONFIG, heartbeatInterval: 10 });
+            await plugin.start();
+            const listener = vi.fn();
+            await plugin.addListener('onHeartbeat', listener);
+            vi.advanceTimersByTime(10_000);
+            getCurrentSuccessCallback(makeGeolocationPosition());
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({
+                location: expect.objectContaining({ isMock: false }),
+            }));
+        });
+    });
+    // -----------------------------------------------------------------------
+    // onMockLocation event — C.3 (never emitted on Web)
+    // -----------------------------------------------------------------------
+    describe('onMockLocation event (C.3)', () => {
+        it('should never emit onMockLocation on Web platform', async () => {
+            await plugin.configure(DEFAULT_CONFIG);
+            const listener = vi.fn();
+            await plugin.addListener('onMockLocation', listener);
+            await plugin.start();
+            // Simulate multiple location updates
+            watchCallback(makeGeolocationPosition());
+            watchCallback(makeGeolocationPosition({ speed: 5 }));
+            watchCallback(makeGeolocationPosition({ speed: 0 }));
+            expect(listener).not.toHaveBeenCalled();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // onPermissionRationale event — C.2 (never emitted on Web)
+    // -----------------------------------------------------------------------
+    describe('onPermissionRationale event (C.2)', () => {
+        it('should never emit onPermissionRationale on Web platform', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onPermissionRationale', listener);
+            await plugin.requestPermissions();
+            expect(listener).not.toHaveBeenCalled();
+        });
+    });
+    // -----------------------------------------------------------------------
+    // Geofencing — in-memory stub on Web
+    // -----------------------------------------------------------------------
+    describe('geofencing (in-memory stub on Web)', () => {
+        const sampleGeofence = {
+            identifier: 'test-1',
+            latitude: 52.2297,
+            longitude: 21.0122,
+            radius: 200,
+        };
+        it('addGeofence should store a geofence in memory', async () => {
+            await plugin.addGeofence(sampleGeofence);
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toHaveLength(1);
+            expect(result.geofences[0].identifier).toBe('test-1');
+        });
+        it('addGeofences should store multiple geofences', async () => {
+            const second = { ...sampleGeofence, identifier: 'test-2' };
+            await plugin.addGeofences({ geofences: [sampleGeofence, second] });
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toHaveLength(2);
+        });
+        it('addGeofence should reject when limit reached', async () => {
+            for (let i = 0; i < 20; i++) {
+                await plugin.addGeofence({ ...sampleGeofence, identifier: `fence-${i}` });
+            }
+            await expect(plugin.addGeofence({ ...sampleGeofence, identifier: 'fence-overflow' })).rejects.toThrow('limit');
+        });
+        it('addGeofence should allow overwriting existing identifier', async () => {
+            await plugin.addGeofence(sampleGeofence);
+            await plugin.addGeofence({ ...sampleGeofence, radius: 500 });
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toHaveLength(1);
+            expect(result.geofences[0].radius).toBe(500);
+        });
+        it('removeGeofence should delete a stored geofence', async () => {
+            await plugin.addGeofence(sampleGeofence);
+            await plugin.removeGeofence({ identifier: 'test-1' });
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toHaveLength(0);
+        });
+        it('removeGeofence should reject for unknown identifier', async () => {
+            await expect(plugin.removeGeofence({ identifier: 'not-found' })).rejects.toThrow('not found');
+        });
+        it('removeAllGeofences should clear all stored geofences', async () => {
+            await plugin.addGeofence(sampleGeofence);
+            await plugin.addGeofence({ ...sampleGeofence, identifier: 'test-2' });
+            await plugin.removeAllGeofences();
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toHaveLength(0);
+        });
+        it('getGeofences should return empty array when no geofences', async () => {
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toEqual([]);
+        });
+        it('onGeofence listener should never emit', async () => {
+            const listener = vi.fn();
+            await plugin.addListener('onGeofence', listener);
+            await plugin.configure(DEFAULT_CONFIG);
+            await plugin.start();
+            // Simulate some activity
+            const position = makeGeolocationPosition();
+            watchCallback(position);
+            expect(listener).not.toHaveBeenCalled();
+        });
+        it('addGeofences should reject when batch would exceed limit', async () => {
+            for (let i = 0; i < 19; i++) {
+                await plugin.addGeofence({ ...sampleGeofence, identifier: `fence-${i}` });
+            }
+            await expect(plugin.addGeofences({
+                geofences: [
+                    { ...sampleGeofence, identifier: 'batch-1' },
+                    { ...sampleGeofence, identifier: 'batch-2' },
+                ],
+            })).rejects.toThrow('limit');
+        });
+        it('removeAllGeofences on empty store should not throw', async () => {
+            await plugin.removeAllGeofences();
+            const result = await plugin.getGeofences();
+            expect(result.geofences).toEqual([]);
+        });
+        it('addGeofence should preserve all config fields', async () => {
+            const fullGeofence = {
+                identifier: 'full-config',
+                latitude: 52.2297,
+                longitude: 21.0122,
+                radius: 300,
+                notifyOnEntry: false,
+                notifyOnExit: true,
+                notifyOnDwell: true,
+                dwellDelay: 600,
+                extras: { zone: 'office' },
+            };
+            await plugin.addGeofence(fullGeofence);
+            const result = await plugin.getGeofences();
+            const stored = result.geofences[0];
+            expect(stored.identifier).toBe('full-config');
+            expect(stored.radius).toBe(300);
+            expect(stored.notifyOnEntry).toBe(false);
+            expect(stored.notifyOnDwell).toBe(true);
+            expect(stored.dwellDelay).toBe(600);
+            expect(stored.extras).toEqual({ zone: 'office' });
+        });
+        it('addGeofence should emit onDebug with geofence info', async () => {
+            const debugListener = vi.fn();
+            await plugin.addListener('onDebug', debugListener);
+            await plugin.configure({ ...DEFAULT_CONFIG, debug: true });
+            await plugin.addGeofence(sampleGeofence);
+            expect(debugListener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('GEOFENCE ADD'),
+            }));
+        });
+        it('removeGeofence should emit onDebug with geofence info', async () => {
+            const debugListener = vi.fn();
+            await plugin.addListener('onDebug', debugListener);
+            await plugin.configure({ ...DEFAULT_CONFIG, debug: true });
+            await plugin.addGeofence(sampleGeofence);
+            await plugin.removeGeofence({ identifier: 'test-1' });
+            expect(debugListener).toHaveBeenCalledWith(expect.objectContaining({
+                message: expect.stringContaining('GEOFENCE REMOVE'),
+            }));
+        });
+    });
+});
+//# sourceMappingURL=web.test.js.map