@bricks-soft/capacitor-location-tracking 0.0.0-stage → 8.0.0

package/dist/plugin.cjs.js

@@ -0,0 +1,945 @@
+'use strict';
+
+var core = require('@capacitor/core');
+
+// Owned by Unit 1 (TS wrapper + web).
+// Capacitor calls the web factory again for every call made before the first one resolves, so the (stateful) web
+// implementation is memoized: concurrent first calls such as `onLocation(...)` + `ready(...)` share one instance.
+let webImplementation;
+/** The Capacitor plugin object. */
+const LocationTracking = core.registerPlugin('LocationTracking', {
+    web: () => webImplementation || (webImplementation = Promise.resolve().then(function () { return web; }).then((m) => new m.LocationTrackingWeb())),
+});
+
+/** Names of every event emitted by the plugin. */
+const Events = {
+    LOCATION: 'location',
+    MOTIONCHANGE: 'motionchange',
+    ACTIVITYCHANGE: 'activitychange',
+    PROVIDERCHANGE: 'providerchange',
+    HEARTBEAT: 'heartbeat',
+    GEOFENCE: 'geofence',
+    GEOFENCESCHANGE: 'geofenceschange',
+    HTTP: 'http',
+    CONNECTIVITYCHANGE: 'connectivitychange',
+    POWERSAVECHANGE: 'powersavechange',
+    ENABLEDCHANGE: 'enabledchange',
+    NOTIFICATIONACTION: 'notificationaction',
+    AUTHORIZATION: 'authorization',
+};
+/**
+ * Subscribes to any plugin event with a typed payload. Call `remove()` on the resolved handle to unsubscribe.
+ * The helpers below are standalone functions on purpose: Capacitor's plugin proxy turns unknown properties of
+ * `LocationTracking` into native calls, so nothing is attached to it.
+ */
+function on(name, callback) {
+    return LocationTracking.addListener(name, callback);
+}
+/** Every recorded location, including persisted `current_position` / `watch_position` fixes and motion changes. */
+const onLocation = (cb) => on('location', cb);
+/** Moving / stationary transitions, with the fix at the moment of the change. */
+const onMotionChange = (cb) => on('motionchange', cb);
+/** Detected activity (still, walking, in_vehicle, ...). */
+const onActivityChange = (cb) => on('activitychange', cb);
+/** Location services or permission changes. */
+const onProviderChange = (cb) => on('providerchange', cb);
+/** Heartbeat records, created when no record was made for `heartbeat.minInterval` seconds while tracking. */
+const onHeartbeat = (cb) => on('heartbeat', cb);
+/** Geofence ENTER / EXIT / DWELL transitions. */
+const onGeofence = (cb) => on('geofence', cb);
+/** Geofences added to or removed from monitoring. */
+const onGeofencesChange = (cb) => on('geofenceschange', cb);
+/** Result of every HTTP upload request. */
+const onHttp = (cb) => on('http', cb);
+/** Network connectivity changes. */
+const onConnectivityChange = (cb) => on('connectivitychange', cb);
+/** Battery-saver mode changes. */
+const onPowerSaveChange = (cb) => on('powersavechange', cb);
+/** Tracking enabled / disabled. */
+const onEnabledChange = (cb) => on('enabledchange', cb);
+/** Taps on the foreground notification's action buttons. */
+const onNotificationAction = (cb) => on('notificationaction', cb);
+/** JWT refresh results. */
+const onAuthorization = (cb) => on('authorization', cb);
+
+/** Never copied: assigning `__proto__` would change the target's prototype instead of adding a key. */
+const PROTO_KEY = '__proto__';
+/** Free-form maps. They are config values, not sections: a new value replaces the old one instead of merging. */
+const MAP_VALUES = [
+    'http.headers',
+    'http.params',
+    'persistence.extras',
+    'http.authorization.refreshPayload',
+    'http.authorization.refreshHeaders',
+];
+/** Sections whose own default is `null`. `null` resets them to `null`; setting them fills in their field defaults. */
+const NULLABLE_SECTIONS = ['http.authorization'];
+/**
+ * Every documented `@default` of {@link Config}, mirroring the Android `Config` model.
+ * Keys without a default (for example `notification.title`, which falls back to the app label) are left out.
+ */
+function defaultConfig() {
+    return {
+        geolocation: {
+            desiredAccuracy: 'high',
+            distanceFilter: 10,
+            locationUpdateInterval: 1000,
+            fastestLocationUpdateInterval: 500,
+            disableElasticity: false,
+            elasticityMultiplier: 1,
+            stationaryRadius: 25,
+            stopTimeout: 5,
+            stopAfterElapsedMinutes: 0,
+            stopOnStationary: false,
+            locationTimeout: 30000,
+            filter: {
+                useKalman: false,
+                trackingAccuracyThreshold: 100,
+                maxImpliedSpeed: 80,
+                odometerAccuracyThreshold: 20,
+                allowIdenticalLocations: false,
+                rejectMockLocations: false,
+            },
+        },
+        activity: {
+            disableMotionActivityUpdates: false,
+            activityRecognitionInterval: 10000,
+            minimumActivityRecognitionConfidence: 75,
+            motionTriggerDelay: 0,
+            disableStopDetection: false,
+        },
+        heartbeat: {
+            enabled: true,
+            minInterval: 180,
+            maxInterval: 300,
+        },
+        http: {
+            url: null,
+            method: 'POST',
+            headers: {},
+            params: {},
+            autoSync: true,
+            autoSyncThreshold: 0,
+            syncInterval: 0,
+            batchSync: false,
+            maxBatchSize: 100,
+            disableAutoSyncOnCellular: false,
+            rootProperty: 'location',
+            locationTemplate: null,
+            geofenceTemplate: null,
+            timeout: 60000,
+            authorization: null,
+        },
+        persistence: {
+            maxDaysToPersist: 7,
+            maxRecordsToPersist: -1,
+            extras: {},
+        },
+        app: {
+            stopOnTerminate: true,
+            startOnBoot: false,
+        },
+        notification: {
+            text: 'Location tracking is active',
+            smallIcon: 'drawable/lt_ic_notification',
+            priority: 'default',
+            channelId: 'location_tracking',
+            channelName: 'Location tracking',
+            actions: [],
+            resume: {
+                enabled: false,
+                text: 'Location tracking is paused. Tap to resume.',
+                channelName: 'Paused location tracking',
+            },
+        },
+        geofence: {
+            initialTriggerEntry: true,
+        },
+        logger: {
+            logLevel: 'info',
+            logMaxDays: 3,
+        },
+        backgroundPermissionRationale: {},
+        locationProvider: 'auto',
+    };
+}
+/** Field defaults of `http.authorization`, applied once it is set (the section itself defaults to `null`). */
+function defaultAuthorization() {
+    return {
+        strategy: 'JWT',
+        refreshPayload: {},
+        refreshHeaders: {},
+        refreshPayloadEncoding: 'json',
+        expires: -1,
+    };
+}
+function defaultTrees() {
+    const sections = defaultConfig();
+    sections.http.authorization = defaultAuthorization();
+    return { values: defaultConfig(), sections };
+}
+function isPlainObject(value) {
+    return Object.prototype.toString.call(value) === '[object Object]';
+}
+/** Deep copy of JSON-like data (plain objects, arrays and primitives). */
+function cloneJson(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => cloneJson(item));
+    }
+    if (isPlainObject(value)) {
+        const copy = {};
+        for (const key of Object.keys(value)) {
+            if (key !== PROTO_KEY) {
+                copy[key] = cloneJson(value[key]);
+            }
+        }
+        return copy;
+    }
+    return value;
+}
+function lookup(tree, path) {
+    let node = tree;
+    for (const key of path) {
+        if (!isPlainObject(node)) {
+            return undefined;
+        }
+        node = node[key];
+    }
+    return node;
+}
+function hasValue(patch) {
+    return Object.keys(patch).some((key) => patch[key] !== undefined && patch[key] !== null);
+}
+function mergeInto(target, patch, path, trees) {
+    for (const key of Object.keys(patch)) {
+        const value = patch[key];
+        if (value === undefined || key === PROTO_KEY) {
+            continue;
+        }
+        const childPath = path.concat(key);
+        const dotted = childPath.join('.');
+        const sectionDefaults = lookup(trees.sections, childPath);
+        const isSection = isPlainObject(sectionDefaults) && MAP_VALUES.indexOf(dotted) < 0;
+        if (value === null) {
+            // null resets the key to its default (fields of a null section use the section's field defaults);
+            // keys without a default are removed.
+            const own = lookup(trees.values, childPath);
+            const reset = own !== undefined ? own : sectionDefaults;
+            if (reset === undefined) {
+                delete target[key];
+            }
+            else {
+                target[key] = cloneJson(reset);
+            }
+        }
+        else if (isSection) {
+            // A section only accepts an object; anything else is ignored so the section stays fully populated.
+            const current = target[key];
+            // A null section is only switched on by a patch that sets something.
+            const staysNull = NULLABLE_SECTIONS.indexOf(dotted) >= 0 && current === null && !hasValue(value);
+            if (isPlainObject(value) && !staysNull) {
+                const base = isPlainObject(current) ? current : cloneJson(sectionDefaults);
+                mergeInto(base, value, childPath, trees);
+                target[key] = base;
+            }
+        }
+        else {
+            // Arrays, maps and scalar values are replaced.
+            target[key] = cloneJson(value);
+        }
+    }
+}
+/** The same clamps the Android config validator applies. */
+function clamp(config) {
+    const heartbeat = config.heartbeat;
+    if (heartbeat) {
+        if (typeof heartbeat.minInterval === 'number' && heartbeat.minInterval < 60) {
+            heartbeat.minInterval = 60;
+        }
+        if (typeof heartbeat.minInterval === 'number' &&
+            typeof heartbeat.maxInterval === 'number' &&
+            heartbeat.maxInterval < heartbeat.minInterval) {
+            heartbeat.maxInterval = heartbeat.minInterval;
+        }
+    }
+    const activity = config.activity;
+    if (activity && typeof activity.minimumActivityRecognitionConfidence === 'number') {
+        activity.minimumActivityRecognitionConfidence = Math.min(100, Math.max(0, activity.minimumActivityRecognitionConfidence));
+    }
+    const http = config.http;
+    if (http && typeof http.maxBatchSize === 'number' && http.maxBatchSize < 1) {
+        http.maxBatchSize = 1;
+    }
+    if (http && typeof http.syncInterval === 'number' && http.syncInterval < 0) {
+        http.syncInterval = 0;
+    }
+    const notification = config.notification;
+    if (notification && Array.isArray(notification.actions) && notification.actions.length > 3) {
+        notification.actions = notification.actions.slice(0, 3);
+    }
+}
+/**
+ * Returns `base` deep-merged with `patch`, without changing either.
+ * - Sections are merged key by key; arrays, maps (`headers`, `params`, `extras`, ...) and scalars are replaced.
+ * - `null` resets a key to its default (`http.authorization` resets to `null`); `undefined` is ignored.
+ */
+function mergeConfig(base, patch) {
+    const result = cloneJson(base);
+    if (patch) {
+        mergeInto(result, patch, [], defaultTrees());
+    }
+    const config = result;
+    clamp(config);
+    return config;
+}
+/** The web `State`: tracking is never enabled on web, and nothing is recorded or persisted. */
+function webState(config) {
+    return {
+        enabled: false,
+        trackingMode: 'location',
+        isMoving: false,
+        odometer: 0,
+        backend: 'web',
+        lastRecordAt: null,
+        config: cloneJson(config),
+    };
+}
+
+/** Keep in sync with `package.json` (a test checks this) and `PLUGIN_VERSION` in `android/build.gradle`. */
+const PLUGIN_VERSION = '8.0.0';
+/** Tokens after `Android x` that do not name a device ('K' is Chrome's reduced user agent). */
+const NOT_A_MODEL = ['K', 'U', 'wv', 'Mobile', 'Tablet', 'HarmonyOS'];
+/** The device model among the `;`-separated tokens that follow `Android x` in the user agent's comment. */
+function androidModel(tokens) {
+    for (const token of tokens) {
+        const model = token.replace(/\s*Build\/.*$/, '').trim();
+        const skip = !model ||
+            NOT_A_MODEL.indexOf(model) >= 0 ||
+            /^[a-z]{2}(?:[-_][a-z]{2})?$/i.test(model) || // locale, e.g. en-us
+            /^(?:rv:|HMSCore)/.test(model);
+        if (!skip) {
+            return model;
+        }
+    }
+    return undefined;
+}
+function parseOs(ua) {
+    let match = /\(([^)]*?)Android\s*([\d.]*)([^)]*)\)/.exec(ua);
+    if (match) {
+        return {
+            osVersion: match[2] ? `Android ${match[2]}` : 'Android',
+            manufacturer: 'unknown',
+            model: androidModel(match[3].split(';')),
+        };
+    }
+    match = /(iPhone|iPad|iPod).*?OS (\d+(?:_\d+)*)/.exec(ua);
+    if (match) {
+        return { osVersion: `iOS ${match[2].replace(/_/g, '.')}`, manufacturer: 'Apple', model: match[1] };
+    }
+    match = /Mac OS X (\d+(?:[_.]\d+)*)/.exec(ua);
+    if (match) {
+        return { osVersion: `macOS ${match[1].replace(/_/g, '.')}`, manufacturer: 'Apple', model: 'Macintosh' };
+    }
+    match = /Windows NT (\d+(?:\.\d+)*)/.exec(ua);
+    if (match) {
+        return { osVersion: `Windows ${match[1]}`, manufacturer: 'unknown', model: undefined };
+    }
+    match = /CrOS \S+ (\d+(?:\.\d+)*)/.exec(ua);
+    if (match) {
+        return { osVersion: `ChromeOS ${match[1]}`, manufacturer: 'unknown', model: undefined };
+    }
+    if (/Linux/.test(ua)) {
+        return { osVersion: 'Linux', manufacturer: 'unknown', model: undefined };
+    }
+    return { osVersion: 'unknown', manufacturer: 'unknown', model: undefined };
+}
+/** Browser name and major version, e.g. `Chrome 120`. Order matters: many browsers also claim Chrome or Safari. */
+function parseBrowser(ua) {
+    const browsers = [
+        ['Edge', /Edg(?:e|A|iOS)?\/(\d+)/],
+        ['Opera', /(?:OPR|Opera)\/(\d+)/],
+        ['Samsung Internet', /SamsungBrowser\/(\d+)/],
+        ['Huawei Browser', /HuaweiBrowser\/(\d+)/],
+        ['Firefox', /(?:Firefox|FxiOS)\/(\d+)/],
+        ['Chrome', /(?:Chrome|CriOS)\/(\d+)/],
+        ['Safari', /Version\/(\d+)[\d.]*.*Safari\//],
+        ['Node.js', /Node\.js\/(\d+)/],
+    ];
+    for (const [name, pattern] of browsers) {
+        const match = pattern.exec(ua);
+        if (match) {
+            return `${name} ${match[1]}`;
+        }
+    }
+    return 'unknown';
+}
+/**
+ * Best-effort `DeviceInfo` for a browser, parsed from `navigator.userAgent`.
+ * `brand` is the browser, `model` the device when the user agent names one (else `navigator.platform`),
+ * `osVersion` includes the OS name, and `sdkInt` is -1 because there is no Android API level.
+ */
+function webDeviceInfo(userAgent, platform) {
+    const os = parseOs(userAgent);
+    return {
+        platform: 'web',
+        manufacturer: os.manufacturer,
+        model: os.model || platform || 'unknown',
+        brand: parseBrowser(userAgent),
+        osVersion: os.osVersion,
+        sdkInt: -1,
+        pluginVersion: PLUGIN_VERSION,
+        gmsAvailable: false,
+        hmsAvailable: false,
+        backend: 'web',
+        packagedProviders: [],
+    };
+}
+
+// Owned by Unit 1 (TS wrapper + web).
+/** A rejection shaped like the native bridge's: a `CapacitorException` whose `code` is an `ErrorCode`. */
+function webError(code, message) {
+    return new core.CapacitorException(message, code);
+}
+/** `GeolocationPositionError.code`: 1 = PERMISSION_DENIED, 2 = POSITION_UNAVAILABLE, 3 = TIMEOUT. */
+function positionErrorInfo(error) {
+    const raw = error && typeof error.code === 'number' ? error.code : 0;
+    const code = raw === 1 ? 'PERMISSION_DENIED' : raw === 3 ? 'TIMEOUT' : 'UNAVAILABLE';
+    const fallback = code === 'PERMISSION_DENIED'
+        ? 'Location permission denied.'
+        : code === 'TIMEOUT'
+            ? 'Timed out waiting for a location.'
+            : 'Location unavailable.';
+    const message = error && typeof error.message === 'string' && error.message ? error.message : fallback;
+    return { code, message };
+}
+
+/** Largest delay `setTimeout` accepts; longer delays would fire immediately. */
+const MAX_TIMER_MS = 2147483647;
+/** How long the permission probe waits for a fix once the user has answered the prompt. */
+const PROBE_TIMEOUT_MS = 10000;
+/** Overall limit for the permission probe: some browsers never call back when their prompt is dismissed. */
+const PROBE_DEADLINE_MS = 60000;
+/** Returns `navigator.geolocation`, or `undefined` when the browser has none. */
+function browserGeolocation() {
+    return typeof navigator !== 'undefined' && navigator && navigator.geolocation ? navigator.geolocation : undefined;
+}
+/**
+ * Takes up to `samples` fixes with consecutive `getCurrentPosition` calls and resolves the most accurate one.
+ * The whole run shares one deadline (`timeout`). When the deadline passes, or a later call fails, it resolves the
+ * best fix taken so far; with no fix it rejects with `TIMEOUT`, `PERMISSION_DENIED` or `UNAVAILABLE`.
+ */
+function sampleBestPosition(geolocation, options) {
+    return new Promise((resolve, reject) => {
+        const deadline = Date.now() + options.timeout;
+        let best = null;
+        let taken = 0;
+        let done = false;
+        let timer;
+        const finish = (error) => {
+            if (done) {
+                return;
+            }
+            done = true;
+            if (timer !== undefined) {
+                clearTimeout(timer);
+            }
+            if (best) {
+                resolve(best);
+            }
+            else {
+                reject(error || webError('TIMEOUT', `No location within ${options.timeout} ms.`));
+            }
+        };
+        const next = () => {
+            if (done) {
+                return;
+            }
+            try {
+                geolocation.getCurrentPosition((position) => {
+                    if (done) {
+                        return;
+                    }
+                    taken++;
+                    if (!best || position.coords.accuracy <= best.coords.accuracy) {
+                        best = position;
+                    }
+                    if (taken >= options.samples) {
+                        finish();
+                    }
+                    else {
+                        next();
+                    }
+                }, (error) => {
+                    const info = positionErrorInfo(error);
+                    finish(webError(info.code, info.message));
+                }, {
+                    enableHighAccuracy: options.enableHighAccuracy,
+                    maximumAge: taken === 0 ? options.maximumAge : 0,
+                    timeout: Math.max(0, deadline - Date.now()),
+                });
+            }
+            catch (e) {
+                finish(webError('UNAVAILABLE', e instanceof Error ? e.message : String(e)));
+            }
+        };
+        // The browser's own timeout does not run while its permission prompt is open; this deadline does.
+        if (options.timeout <= MAX_TIMER_MS) {
+            timer = setTimeout(() => finish(), options.timeout);
+        }
+        next();
+    });
+}
+/**
+ * Asks for one fix so the browser shows its permission prompt, and waits for the user's answer.
+ * Resolves `'denied'` on PERMISSION_DENIED and `'granted'` otherwise: the browser reports TIMEOUT and
+ * POSITION_UNAVAILABLE only after permission was granted. Resolves `'prompt'` if nothing happens within a minute.
+ */
+function probeLocationPermission(geolocation) {
+    return new Promise((resolve) => {
+        let done = false;
+        const finish = (state) => {
+            if (!done) {
+                done = true;
+                clearTimeout(timer);
+                resolve(state);
+            }
+        };
+        const timer = setTimeout(() => finish('prompt'), PROBE_DEADLINE_MS);
+        try {
+            geolocation.getCurrentPosition(() => finish('granted'), (error) => finish(positionErrorInfo(error).code === 'PERMISSION_DENIED' ? 'denied' : 'granted'), { enableHighAccuracy: false, maximumAge: Infinity, timeout: PROBE_TIMEOUT_MS });
+        }
+        catch (_a) {
+            finish('prompt');
+        }
+    });
+}
+/** State of the browser's `geolocation` permission, or `undefined` when the Permissions API cannot tell. */
+async function queryLocationPermission() {
+    const permissions = typeof navigator !== 'undefined' && navigator ? navigator.permissions : undefined;
+    if (!permissions || typeof permissions.query !== 'function') {
+        return undefined;
+    }
+    try {
+        const status = await permissions.query({ name: 'geolocation' });
+        const state = status.state;
+        return state === 'granted' || state === 'denied' || state === 'prompt' ? state : 'prompt';
+    }
+    catch (_a) {
+        return undefined;
+    }
+}
+
+/** A version 4 UUID: `crypto.randomUUID()`, else built from `crypto.getRandomValues()`, else from `Math.random()`. */
+function uuid() {
+    const webCrypto = typeof crypto !== 'undefined' ? crypto : undefined;
+    if (webCrypto && typeof webCrypto.randomUUID === 'function') {
+        return webCrypto.randomUUID();
+    }
+    const bytes = new Uint8Array(16);
+    if (webCrypto && typeof webCrypto.getRandomValues === 'function') {
+        webCrypto.getRandomValues(bytes);
+    }
+    else {
+        for (let i = 0; i < bytes.length; i++) {
+            bytes[i] = Math.floor(Math.random() * 256);
+        }
+    }
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += (bytes[i] + 0x100).toString(16).slice(1);
+    }
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/** ISO-8601 UTC with milliseconds (`yyyy-MM-ddTHH:mm:ss.SSSZ`). Invalid input falls back to now. */
+function isoTime(epochMs) {
+    const ms = typeof epochMs === 'number' && isFinite(epochMs) ? Math.round(epochMs) : Date.now();
+    return new Date(ms).toISOString();
+}
+/** Monotonic milliseconds since the page's time origin: the closest web equivalent of `elapsedRealtime`. */
+function elapsedMs() {
+    const hasClock = typeof performance !== 'undefined' && typeof performance.now === 'function';
+    return hasClock ? Math.round(performance.now()) : 0;
+}
+function numberOrNull(value) {
+    return typeof value === 'number' && isFinite(value) ? value : null;
+}
+/** Maps a browser fix to the plugin's `Location` record shape. `extras` is left out when empty. */
+function toLocation(position, event, extras) {
+    const coords = position.coords;
+    const location = {
+        uuid: uuid(),
+        event,
+        timestamp: isoTime(position.timestamp),
+        recorded_at: isoTime(Date.now()),
+        elapsed_realtime_ms: elapsedMs(),
+        boot_count: -1,
+        is_moving: false,
+        odometer: 0,
+        mock: false,
+        coords: {
+            latitude: coords.latitude,
+            longitude: coords.longitude,
+            accuracy: coords.accuracy,
+            altitude: numberOrNull(coords.altitude),
+            altitude_accuracy: numberOrNull(coords.altitudeAccuracy),
+            speed: numberOrNull(coords.speed),
+            speed_accuracy: null,
+            heading: numberOrNull(coords.heading),
+            heading_accuracy: null,
+        },
+        activity: { type: 'unknown', confidence: 0 },
+        battery: { level: -1, is_charging: false },
+        backend: 'web',
+    };
+    if (extras && Object.keys(extras).length > 0) {
+        location.extras = extras;
+    }
+    return location;
+}
+
+// Owned by Unit 1 (TS wrapper + web).
+const ALL_PERMISSIONS = ['location', 'notifications', 'activityRecognition', 'backgroundLocation'];
+function highAccuracy(accuracy) {
+    return accuracy === undefined || accuracy === 'high';
+}
+function nonNegative(value, fallback) {
+    return typeof value === 'number' && value >= 0 ? value : fallback;
+}
+/** The defaults plus `options.config` (optional; must be an object when given). */
+function configFromDefaults(options) {
+    const given = options ? options.config : undefined;
+    if (given !== undefined && given !== null && !isPlainObject(given)) {
+        throw webError('INVALID_ARGUMENT', 'config must be an object.');
+    }
+    return mergeConfig(defaultConfig(), given || undefined);
+}
+/**
+ * Web implementation. It covers `getCurrentPosition`, `watchPosition` and `clearWatch` (via `navigator.geolocation`),
+ * an in-memory config and state, permissions and device info. Nothing is persisted or uploaded, and tracking cannot
+ * be started. Every other method rejects with `UNIMPLEMENTED`.
+ *
+ * Like the Android bridge, methods other than `ready`, `getState`, `checkPermissions`, `requestPermissions` and
+ * `getDeviceInfo` reject with `NOT_READY` until `ready()` has resolved.
+ */
+class LocationTrackingWeb extends core.WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.config = defaultConfig();
+        this.isReady = false;
+        this.lastPosition = null;
+        this.watchSeq = 0;
+        this.watches = new Map();
+    }
+    async ready(options) {
+        const config = configFromDefaults(options);
+        // reset:false applies the given config only on the first ready(); afterwards the current config wins.
+        if (!options || options.reset !== false || !this.isReady) {
+            this.config = config;
+        }
+        this.isReady = true;
+        return webState(this.config);
+    }
+    async setConfig(options) {
+        this.requireReady();
+        if (!options || !isPlainObject(options.config)) {
+            throw webError('INVALID_ARGUMENT', 'config must be an object.');
+        }
+        this.config = mergeConfig(this.config, options.config);
+        return webState(this.config);
+    }
+    async reset(options) {
+        this.requireReady();
+        this.config = configFromDefaults(options);
+        return webState(this.config);
+    }
+    async getState() {
+        return webState(this.config);
+    }
+    async start() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async startGeofences() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async stop() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async changePace(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    /**
+     * Takes `samples` fixes within `timeout` and resolves the most accurate one. With `maximumAge > 0`, a fix this
+     * plugin received at most that long ago is returned right away. Like a persisted record on Android, the result is
+     * also emitted as a `location` event unless `persist` is false.
+     */
+    async getCurrentPosition(options) {
+        var _a;
+        this.requireReady();
+        const geolocation = this.requireGeolocation();
+        const o = options || {};
+        const maximumAge = nonNegative(o.maximumAge, 0);
+        const cached = this.lastPosition;
+        let position;
+        if (maximumAge > 0 && cached && Date.now() - cached.timestamp <= maximumAge) {
+            position = cached;
+        }
+        else {
+            const samples = typeof o.samples === 'number' && o.samples >= 1 ? Math.floor(o.samples) : 3;
+            position = await sampleBestPosition(geolocation, {
+                samples,
+                timeout: nonNegative(o.timeout, nonNegative((_a = this.config.geolocation) === null || _a === void 0 ? void 0 : _a.locationTimeout, 30000)),
+                maximumAge,
+                enableHighAccuracy: highAccuracy(o.desiredAccuracy),
+            });
+        }
+        this.lastPosition = position;
+        const location = toLocation(position, 'current_position', this.recordExtras(o.extras));
+        if (o.persist !== false) {
+            this.emit('location', location);
+        }
+        return location;
+    }
+    /**
+     * Starts `navigator.geolocation.watchPosition` and resolves its id. The callback gets each fix as a
+     * `watch_position` Location, or `(null, { code, message })` on error. `interval` is ignored: the browser decides
+     * how often fixes arrive. With `persist: true` each fix is also emitted as a `location` event.
+     */
+    async watchPosition(options, callback) {
+        this.requireReady();
+        if (typeof callback !== 'function') {
+            throw webError('INVALID_ARGUMENT', 'watchPosition requires a callback.');
+        }
+        const geolocation = this.requireGeolocation();
+        const o = options || {};
+        const callExtras = cloneJson(o.extras);
+        const persist = o.persist === true;
+        const entry = { active: true, geolocation, browserId: 0 };
+        try {
+            entry.browserId = geolocation.watchPosition((position) => {
+                // Browsers may still deliver a queued fix after clearWatch.
+                if (!entry.active) {
+                    return;
+                }
+                this.lastPosition = position;
+                const location = toLocation(position, 'watch_position', this.recordExtras(callExtras));
+                if (persist) {
+                    this.emit('location', location);
+                }
+                callback(location);
+            }, (error) => {
+                if (entry.active) {
+                    callback(null, positionErrorInfo(error));
+                }
+            }, { enableHighAccuracy: highAccuracy(o.desiredAccuracy), maximumAge: 0 });
+        }
+        catch (e) {
+            throw webError('UNAVAILABLE', e instanceof Error ? e.message : String(e));
+        }
+        const id = `web-watch-${++this.watchSeq}`;
+        this.watches.set(id, entry);
+        return id;
+    }
+    /** Stops a watch. Unknown ids are ignored. */
+    async clearWatch(options) {
+        this.requireReady();
+        if (!options || typeof options.id !== 'string') {
+            throw webError('INVALID_ARGUMENT', 'id must be a string.');
+        }
+        const entry = this.watches.get(options.id);
+        if (!entry) {
+            return;
+        }
+        this.watches.delete(options.id);
+        entry.active = false;
+        entry.geolocation.clearWatch(entry.browserId);
+    }
+    async getOdometer() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async setOdometer(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async resetOdometer() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getLocations(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getCount() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async insertLocation(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async destroyLocations() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async destroyLocation(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async sync() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async addGeofence(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async addGeofences(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async removeGeofence(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async removeGeofences(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getGeofences() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getGeofence(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async geofenceExists(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getHeartbeatStatus() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getProviderState() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async isPowerSaveMode() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getBatteryOptimizationStatus() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async openBatteryOptimizationSettings() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getPowerManagerInfo() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async openPowerManagerSettings() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async openLocationSettings() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async openAppSettings() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    /** Best-effort values parsed from `navigator.userAgent`; `platform` is `'web'`. */
+    async getDeviceInfo() {
+        const nav = typeof navigator !== 'undefined' && navigator ? navigator : undefined;
+        return webDeviceInfo(nav && typeof nav.userAgent === 'string' ? nav.userAgent : '', nav ? nav.platform : undefined);
+    }
+    async getSensors() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    /** `location` comes from the Permissions API (`'prompt'` when it cannot tell); the other three are `'granted'`. */
+    async checkPermissions() {
+        const location = await queryLocationPermission();
+        return {
+            location: location || 'prompt',
+            backgroundLocation: 'granted',
+            activityRecognition: 'granted',
+            notifications: 'granted',
+        };
+    }
+    /** When `location` is requested and still undecided, asks for a fix so the browser prompts, then reports. */
+    async requestPermissions(options) {
+        const requested = options && Array.isArray(options.permissions) ? options.permissions : ALL_PERMISSIONS;
+        const status = await this.checkPermissions();
+        const geolocation = browserGeolocation();
+        if (requested.indexOf('location') < 0 || status.location !== 'prompt' || !geolocation) {
+            return status;
+        }
+        const answer = await probeLocationPermission(geolocation);
+        // A granted probe is proof, even for a one-time grant the Permissions API still reports as 'prompt'. Otherwise
+        // prefer the Permissions API: a dismissed prompt fails the probe as denied but leaves the permission at 'prompt'.
+        status.location = answer === 'granted' ? answer : (await queryLocationPermission()) || answer;
+        return status;
+    }
+    async log(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async getLog(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async destroyLog() {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async uploadLog(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    async emailLog(_options) {
+        throw this.unimplemented('Not implemented on web.');
+    }
+    requireReady() {
+        if (!this.isReady) {
+            throw webError('NOT_READY', 'Call ready() before using this method.');
+        }
+    }
+    requireGeolocation() {
+        const geolocation = browserGeolocation();
+        if (!geolocation) {
+            throw webError('UNAVAILABLE', 'navigator.geolocation is not available.');
+        }
+        return geolocation;
+    }
+    /** `persistence.extras` merged with the call's extras (the call wins), like records created on Android. */
+    recordExtras(extras) {
+        const persisted = this.config.persistence ? this.config.persistence.extras : undefined;
+        const merged = {};
+        if (isPlainObject(persisted)) {
+            Object.assign(merged, cloneJson(persisted));
+        }
+        if (isPlainObject(extras)) {
+            Object.assign(merged, cloneJson(extras));
+        }
+        return Object.keys(merged).length > 0 ? merged : undefined;
+    }
+    /**
+     * Like `notifyListeners`, but each listener gets its own copy of the payload (as on native, where every listener
+     * receives deserialized data), and a throwing listener neither skips the others nor fails the calling method.
+     */
+    emit(eventName, data) {
+        const listeners = this.listeners[eventName];
+        if (!listeners) {
+            return;
+        }
+        for (const listener of listeners.slice()) {
+            try {
+                listener(cloneJson(data));
+            }
+            catch (e) {
+                console.error(`LocationTracking: "${eventName}" listener threw`, e);
+            }
+        }
+    }
+}
+
+var web = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    LocationTrackingWeb: LocationTrackingWeb
+});
+
+exports.Events = Events;
+exports.LocationTracking = LocationTracking;
+exports.on = on;
+exports.onActivityChange = onActivityChange;
+exports.onAuthorization = onAuthorization;
+exports.onConnectivityChange = onConnectivityChange;
+exports.onEnabledChange = onEnabledChange;
+exports.onGeofence = onGeofence;
+exports.onGeofencesChange = onGeofencesChange;
+exports.onHeartbeat = onHeartbeat;
+exports.onHttp = onHttp;
+exports.onLocation = onLocation;
+exports.onMotionChange = onMotionChange;
+exports.onNotificationAction = onNotificationAction;
+exports.onPowerSaveChange = onPowerSaveChange;
+exports.onProviderChange = onProviderChange;
+//# sourceMappingURL=plugin.cjs.js.map