map-gl-offline 0.6.0 → 0.7.0

package/README.md

@@ -160,6 +160,8 @@ try {
 }
 ```
 
+> **Upgrading from 0.5.x?** Read the [0.6.0 migration guide](https://map-gl-offline.netlify.app/docs/migration-0.6) — covers the rename of `ResourceService.getXxxStatistics` → `getXxxStats`, the `addRegion` vs `downloadRegion` split, and the `expiry` timestamp fix.
+
 ## API at a glance
 
 - **Regions** — `downloadRegion`, `loadRegion`, `addRegion`, `getStoredRegion`, `listStoredRegions`, `listRegions`, `deleteRegion`

package/dist/index.d.ts

@@ -58,6 +58,7 @@ export * from './services/tileService';
 export * from './services/fontService';
 export * from './services/glyphService';
 export * from './services/spriteService';
+export * from './services/modelService';
 export * from './services/cleanupService';
 export * from './services/styleService';
 export * from './services/regionService';

package/dist/index.esm.js

@@ -12,7 +12,7 @@ import { polygon, convertArea, featureCollection } from '@turf/helpers';
  */
 // IndexedDB Configuration
 const DB_NAME = 'offline-map-db';
-const DB_VERSION = 3;
+const DB_VERSION = 4;
 // Store Names (regions are stored inside styles.regions[], not as a separate store)
 const STORE_NAMES = {
     TILES: 'tiles',
@@ -20,6 +20,7 @@ const STORE_NAMES = {
     SPRITES: 'sprites',
     GLYPHS: 'glyphs',
     FONTS: 'fonts',
+    MODELS: 'models',
 };
 // Download Configuration
 const DOWNLOAD_DEFAULTS = {
@@ -227,7 +228,7 @@ async function resetOfflineMapDB() {
  * Called during initial database creation or when stores are missing.
  */
 function createStores(db) {
-    const stores = ['regions', 'tiles', 'styles', 'sprites', 'glyphs', 'fonts'];
+    const stores = ['regions', 'tiles', 'styles', 'sprites', 'glyphs', 'fonts', 'models'];
     for (const storeName of stores) {
         if (!db.objectStoreNames.contains(storeName)) {
             db.createObjectStore(storeName, { keyPath: 'key' });
@@ -309,6 +310,7 @@ function migrateRegionsToStyles(transaction) {
  * - sprites: Sprite images and JSON
  * - glyphs: Font glyph data
  * - fonts: Font files
+ * - models: 3D model files (.glb) for Mapbox Standard tree/turbine layers
  * - regions: (deprecated) Legacy region storage, migrated to styles.regions[]
  *
  * @example
@@ -328,6 +330,9 @@ async function openOfflineMapDB() {
                 if (oldVersion > 0 && oldVersion < 3) {
                     migrateRegionsToStyles(transaction);
                 }
+                // Migration: v3 -> v4
+                // Adds the `models` store for Mapbox Standard 3D model assets.
+                // No data migration needed — createStores above handles it.
             },
         });
     }
@@ -1184,6 +1189,7 @@ const idbLogger = logger.scope('IDBFetch');
 // idb://{downloadId}/tile/{sourceKey}/{url}
 // idb://{downloadId}/glyph/{fontstack}/{range}.pbf
 // idb://{downloadId}/sprite/{spriteName}
+// idb://{styleId}/model/{modelName}
 // idb://{downloadId}/tilesjson/{url}
 // Cache for region ID to style mapping to avoid repeated DB queries
 const regionToStyleCache = new Map();
@@ -1555,6 +1561,33 @@ async function idbFetchHandler(url, init) {
                 }
                 break;
             }
+            case 'model': {
+                // Model URLs are rewritten by patchStyleForOffline to:
+                //   idb://{styleId}/model/{modelName}
+                // Models are keyed by {styleId}::model::{modelName} in the store.
+                // Mirror the sprite resolution fallback: try the style ID first,
+                // then the download/region ID (in case the request came through a
+                // region-scoped URL).
+                const styleEntry = await findStyleByRegionId(db, downloadId);
+                const actualStyleId = styleEntry?.key || downloadId;
+                const candidates = Array.from(new Set([
+                    `${actualStyleId}::model::${decodedResourcePath}`,
+                    `${downloadId}::model::${decodedResourcePath}`,
+                ]));
+                idbLogger.debug(`Model candidates for "${decodedResourcePath}":`, candidates);
+                for (const candidateKey of candidates) {
+                    const resource = await db.get('models', candidateKey);
+                    if (resource?.data) {
+                        idbLogger.debug(`Found model using key: ${candidateKey}`);
+                        return new Response(resource.data, {
+                            status: 200,
+                            headers: { 'Content-Type': resource.contentType || 'model/gltf-binary' },
+                        });
+                    }
+                }
+                idbLogger.warn(`Model not found, tried keys: ${candidates.join(', ')}`);
+                break;
+            }
             case 'tilesjson': {
                 idbLogger.debug(`Looking for tilejson with downloadId: ${downloadId}, resourcePath: ${decodedResourcePath}`);
                 // First try direct lookup (for style-level downloads)
@@ -2010,14 +2043,29 @@ function patchStyleForOffline(style, downloadId, maxZoom, tileExtension, styleId
             });
         }
     }
-    // Patch top-level models (Mapbox Standard 3D landmarks)
+    // Patch top-level models (Mapbox Standard 3D trees / wind turbines).
+    // Two shapes exist in the wild:
+    //   - Mapbox Standard: `{ "maple1-lod1": "mapbox://models/mapbox/maple1-v4-lod1.glb" }` (string values)
+    //   - Older/generic:   `{ "name": { "uri": "mapbox://..." } }`               (object values)
+    // Models are keyed on the style ID (like sprites) so they can be shared
+    // across regions.
     if (style.models) {
-        for (const [modelId, modelConfig] of Object.entries(style.models)) {
-            if (modelConfig.uri) {
-                modelConfig.uri = `idb://${downloadId}/model/${modelId}`;
+        const modelBaseId = styleId || downloadId;
+        const models = style.models;
+        let patchedCount = 0;
+        for (const [modelId, value] of Object.entries(models)) {
+            if (typeof value === 'string') {
+                models[modelId] = `idb://${modelBaseId}/model/${modelId}`;
+                patchedCount++;
+            }
+            else if (value && typeof value === 'object' && 'uri' in value && value.uri) {
+                value.uri = `idb://${modelBaseId}/model/${modelId}`;
+                patchedCount++;
             }
         }
-        styleLogger.debug(`Patched ${Object.keys(style.models).length} model URIs`);
+        if (patchedCount > 0) {
+            styleLogger.debug(`Patched ${patchedCount} model URIs (styleId: ${modelBaseId})`);
+        }
     }
     styleLogger.debug(`Final patched style:`, style);
     return style;
@@ -2585,12 +2633,22 @@ function convertStyleForServiceWorker(style) {
             });
         }
     }
-    // Convert models
+    // Convert models. Two shapes in the wild:
+    //   - Mapbox Standard: `{ name: "idb://..." }` (string value)
+    //   - Older/generic:   `{ name: { uri: "idb://..." } }` (object value)
     if (converted.models) {
-        for (const modelKey of Object.keys(converted.models)) {
-            const model = converted.models[modelKey];
-            if (model.uri && typeof model.uri === 'string' && model.uri.startsWith('idb://')) {
-                model.uri = replace(model.uri);
+        const models = converted.models;
+        for (const modelKey of Object.keys(models)) {
+            const value = models[modelKey];
+            if (typeof value === 'string') {
+                if (value.startsWith('idb://')) {
+                    models[modelKey] = replace(value);
+                }
+            }
+            else if (value && typeof value === 'object') {
+                if (typeof value.uri === 'string' && value.uri.startsWith('idb://')) {
+                    value.uri = replace(value.uri);
+                }
             }
         }
     }
@@ -4911,7 +4969,15 @@ class RegionService {
                 deletedSprites++;
             }
         }
-        regionLogger$1.info(`Deleted style resources: ${deletedFonts} fonts, ${deletedGlyphs} glyphs, ${deletedSprites} sprites`);
+        let deletedModels = 0;
+        const modelTx = db.transaction('models', 'readwrite');
+        for await (const cursor of modelTx.store) {
+            if (resourceKeyBelongsToStyle(cursor.value.key, styleId)) {
+                await cursor.delete();
+                deletedModels++;
+            }
+        }
+        regionLogger$1.info(`Deleted style resources: ${deletedFonts} fonts, ${deletedGlyphs} glyphs, ${deletedSprites} sprites, ${deletedModels} models`);
     }
     /**
      * Delete all tiles for a style
@@ -5019,7 +5085,7 @@ class RegionService {
         if (!region.styleUrl) {
             throw new Error('Region must have a styleUrl');
         }
-        const { onProgress, provider = 'auto', accessToken, skipGlyphs = false, skipSprites = false, glyphRanges, tileOptions, } = options;
+        const { onProgress, provider = 'auto', accessToken, skipGlyphs = false, skipSprites = false, skipModels = false, glyphRanges, tileOptions, } = options;
         const emit = (phase, completed, total, message) => {
             if (!onProgress)
                 return;
@@ -5074,8 +5140,13 @@ class RegionService {
             const spriteSources = normalizeSpriteProperty(originalSpriteUrl);
             if (spriteSources.length > 0) {
                 const { downloadSprites } = await Promise.resolve().then(function () { return spriteService$1; });
-                const suffixes = ['.json', '.png', '@2x.json', '@2x.png'];
-                const totalFiles = spriteSources.length * suffixes.length;
+                // Standard four sprite variants. For Mapbox Standard, an `iconset.pbf`
+                // sibling is also served under the same /styles/v1/.../<hash>/ path
+                // — we detect that case per-source below and append it to the list.
+                const baseSuffixes = ['.json', '.png', '@2x.json', '@2x.png'];
+                // Estimate total files assuming iconset is always included (the actual
+                // number may be smaller; the emit helper clamps progress to total).
+                const totalFiles = spriteSources.length * (baseSuffixes.length + 1);
                 let completed = 0;
                 emit('sprites', 0, totalFiles, 'Downloading sprites');
                 for (const source of spriteSources) {
@@ -5084,9 +5155,27 @@ class RegionService {
                         spriteBase = resolveMapboxUrl(spriteBase, effectiveAccessToken);
                     }
                     const qIndex = spriteBase.indexOf('?');
-                    const spriteUrls = suffixes.map(suffix => qIndex !== -1
-                        ? spriteBase.slice(0, qIndex) + suffix + spriteBase.slice(qIndex)
-                        : spriteBase + suffix);
+                    const suffixes = [...baseSuffixes];
+                    // Mapbox Standard serves an iconset.pbf alongside the sprite under
+                    // /styles/v1/{owner}/{style}/{hash}/sprite → the sibling file is
+                    // /styles/v1/{owner}/{style}/{hash}/iconset.pbf. The last path
+                    // segment is `sprite`, so replacing it with `iconset.pbf` works.
+                    const pathWithoutQuery = qIndex !== -1 ? spriteBase.slice(0, qIndex) : spriteBase;
+                    const isMapboxStandardSprite = /api\.mapbox\.com\/styles\/v1\/.+\/sprite$/.test(pathWithoutQuery);
+                    if (isMapboxStandardSprite) {
+                        // The path-rewrite suffix replaces the trailing `sprite` segment.
+                        suffixes.push('__ICONSET__');
+                    }
+                    const spriteUrls = suffixes.map(suffix => {
+                        if (suffix === '__ICONSET__') {
+                            // Replace trailing `sprite` with `iconset.pbf`, preserving query.
+                            const base = pathWithoutQuery.replace(/sprite$/, 'iconset.pbf');
+                            return qIndex !== -1 ? base + spriteBase.slice(qIndex) : base;
+                        }
+                        return qIndex !== -1
+                            ? spriteBase.slice(0, qIndex) + suffix + spriteBase.slice(qIndex)
+                            : spriteBase + suffix;
+                    });
                     try {
                         const result = await downloadSprites(spriteUrls, styleId, {
                             enableValidation: true,
@@ -5132,7 +5221,42 @@ class RegionService {
                 }
             }
         }
-        // 4. Tiles — use the stored (source-embedded) style, which still has HTTP tile URLs
+        // 4. Models — Mapbox Standard's `style.models` references 3D tree /
+        //    turbine .glb assets. Two value shapes exist in the wild
+        //    (plain string or `{ uri }`) — we accept both.
+        let modelResult;
+        if (!skipModels && storedStyle.models) {
+            const rawModels = storedStyle.models;
+            const resolved = {};
+            for (const [name, value] of Object.entries(rawModels)) {
+                const uri = typeof value === 'string' ? value : value?.uri;
+                if (!uri)
+                    continue;
+                if (uri.startsWith('idb://'))
+                    continue; // already patched
+                const httpUrl = isMapboxProtocol(uri) && effectiveAccessToken
+                    ? resolveMapboxUrl(uri, effectiveAccessToken)
+                    : uri;
+                if (httpUrl.startsWith('http://') || httpUrl.startsWith('https://')) {
+                    resolved[name] = httpUrl;
+                }
+            }
+            if (Object.keys(resolved).length > 0) {
+                const { downloadModels } = await Promise.resolve().then(function () { return modelService$1; });
+                emit('models', 0, Object.keys(resolved).length, 'Downloading 3D models');
+                try {
+                    modelResult = await downloadModels(resolved, styleId, {
+                        onProgress: (progress) => {
+                            emit('models', progress.completed, progress.total, 'Downloading 3D models');
+                        },
+                    });
+                }
+                catch (error) {
+                    regionLogger$1.warn('Model download failed (non-fatal):', error);
+                }
+            }
+        }
+        // 5. Tiles — use the stored (source-embedded) style, which still has HTTP tile URLs
         const { downloadTiles } = await Promise.resolve().then(function () { return tileService$1; });
         const regionForTiles = { ...region, styleId };
         emit('tiles', 0, 100, 'Downloading tiles');
@@ -5145,7 +5269,7 @@ class RegionService {
                 tileOptions?.onProgress?.(progress);
             },
         });
-        // 5. Metadata — must run last, since addRegion patches style URLs to idb://.
+        // 6. Metadata — must run last, since addRegion patches style URLs to idb://.
         // Do NOT auto-fill tileExtension from tileResult: that's only the first
         // source's extension, and addRegion feeds it to patchStyleForOffline which
         // would override ALL sources — breaking mixed raster+vector styles. The
@@ -5161,6 +5285,7 @@ class RegionService {
             styleResult,
             spriteResults,
             glyphResult,
+            modelResult,
             tileResult,
         };
     }
@@ -6299,10 +6424,15 @@ class TileService {
                 tilesLength: config.tiles ? config.tiles.length : 0,
                 url: config.url,
             });
-            // Handle tile-based sources (vector, raster, raster-dem, batched-model)
+            // Handle tile-based sources (vector, raster, raster-dem, batched-model,
+            // raster-array). `raster-array` is used by Mapbox Standard for layers
+            // like `mapbox-landmarks` (mapbox.mapbox-landmark-icons-v1) — the tiles
+            // are fetched from the same /v4/ endpoint as other tilesets, so the
+            // TileJSON resolution path below handles them uniformly.
             if (config.type === 'vector' ||
                 config.type === 'raster' ||
                 config.type === 'raster-dem' ||
+                config.type === 'raster-array' ||
                 config.type === 'batched-model') {
                 // Handle direct tile URLs in the source config
                 if (config.tiles && Array.isArray(config.tiles) && config.tiles.length > 0) {
@@ -7035,6 +7165,201 @@ var glyphService$1 = /*#__PURE__*/Object.freeze({
     verifyAndRepairGlyphs: verifyAndRepairGlyphs
 });
 
+const modelLogger = logger.scope('ModelService');
+/**
+ * Build the storage key for a model. Kept consistent with sprite/glyph
+ * conventions: `{styleId}::model::{modelName}`.
+ */
+function modelKey(styleId, modelName) {
+    return `${styleId}::model::${modelName}`;
+}
+/** True when the given key belongs to the given styleId's model store prefix. */
+function modelKeyBelongsToStyle(key, styleId) {
+    return key.startsWith(`${styleId}::model::`);
+}
+/**
+ * Service for downloading, storing, and serving Mapbox 3D model (.glb) files.
+ *
+ * Mapbox Standard declares 32 models at the top of `style.models`:
+ *
+ * ```json
+ * {
+ *   "maple1-lod1": "mapbox://models/mapbox/maple1-v4-lod1.glb",
+ *   ...
+ * }
+ * ```
+ *
+ * `model` layers (e.g. `trees`, `wind-turbine-towers`) pick one by name at
+ * render time. For offline use each referenced URL is fetched and stored
+ * here, and `patchStyleForOffline` rewrites the dictionary entries to
+ * `idb://{styleId}/model/{name}` URLs.
+ */
+class ModelService {
+    db = dbPromise;
+    /**
+     * Download the set of models referenced by `style.models` for one style.
+     *
+     * @param models   `{ modelName: resolvedHttpUrl }` — URLs must already be
+     *                 resolved (mapbox:// URLs should be resolved by the caller).
+     * @param styleId  The owning style's key.
+     */
+    async downloadModels(models, styleId, options = {}) {
+        const db = await this.db;
+        const { onProgress, batchSize = 4, maxRetries = 3, skipExisting = true, timeoutMs = 30000, } = options;
+        const entries = Object.entries(models);
+        const progressTracker = createProgressTracker(entries.length);
+        const result = {
+            totalModels: entries.length,
+            downloadedModels: 0,
+            skippedModels: 0,
+            failedModels: 0,
+            totalSize: 0,
+            errors: [],
+        };
+        const emit = () => onProgress?.(progressTracker.getProgress());
+        emit();
+        if (entries.length === 0)
+            return result;
+        // Pre-compute existing keys for skipExisting
+        const existingKeys = new Set();
+        if (skipExisting) {
+            const tx = db.transaction('models', 'readonly');
+            for await (const cursor of tx.store) {
+                existingKeys.add(cursor.value.key);
+            }
+        }
+        await processBatch(entries, async ([modelName, url]) => {
+            const key = modelKey(styleId, modelName);
+            const label = `${styleId}::${modelName}`;
+            if (skipExisting && existingKeys.has(key)) {
+                result.skippedModels++;
+                progressTracker.update(1, label);
+                emit();
+                return;
+            }
+            try {
+                const response = await fetchResourceWithRetry(url, {
+                    retries: maxRetries,
+                    timeout: timeoutMs,
+                    proxyType: 'tiles',
+                });
+                if (response.type === 'json') {
+                    throw new Error('Unexpected JSON response for model');
+                }
+                const data = response.data;
+                const contentType = ('contentType' in response && response.contentType) || 'model/gltf-binary';
+                const entry = {
+                    key,
+                    data,
+                    contentType,
+                    size: data.byteLength,
+                    url,
+                    styleId,
+                    modelName,
+                    lastModified: Date.now(),
+                    downloadedAt: new Date().toISOString(),
+                    expires: response.expires,
+                };
+                await db.put('models', entry);
+                result.downloadedModels++;
+                result.totalSize += data.byteLength;
+                progressTracker.update(1, label);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                result.failedModels++;
+                result.errors.push({ url, error: message });
+                modelLogger.warn(`Failed to download model "${modelName}" from ${url}:`, err);
+                progressTracker.update(1, label, message);
+            }
+            emit();
+        }, { batchSize });
+        modelLogger.info(`Models downloaded for style ${styleId}: ${result.downloadedModels} new, ${result.skippedModels} skipped, ${result.failedModels} failed`);
+        return result;
+    }
+    /** Retrieve a single model by `{styleId, modelName}`. */
+    async getModel(styleId, modelName) {
+        const db = await this.db;
+        return db.get('models', modelKey(styleId, modelName));
+    }
+    /** Aggregate stats across all stored models. */
+    async getModelStats() {
+        const db = await this.db;
+        const stats = {
+            count: 0,
+            totalSize: 0,
+            averageSize: 0,
+            models: [],
+            modelsByStyle: {},
+        };
+        const tx = db.transaction('models', 'readonly');
+        for await (const cursor of tx.store) {
+            const m = cursor.value;
+            stats.count++;
+            stats.totalSize += m.size;
+            stats.models.push({ name: m.modelName, size: m.size, lastModified: m.lastModified });
+            stats.modelsByStyle[m.styleId] = (stats.modelsByStyle[m.styleId] ?? 0) + 1;
+        }
+        stats.averageSize = stats.count > 0 ? stats.totalSize / stats.count : 0;
+        return stats;
+    }
+    /**
+     * Delete models older than `maxAge` days. Defaults to 30.
+     */
+    async cleanupOldModels(maxAge = 30) {
+        const db = await this.db;
+        const cutoff = Date.now() - maxAge * 24 * 60 * 60 * 1000;
+        let deleted = 0;
+        const tx = db.transaction('models', 'readwrite');
+        for await (const cursor of tx.store) {
+            if (cursor.value.lastModified < cutoff) {
+                await cursor.delete();
+                deleted++;
+            }
+        }
+        return deleted;
+    }
+    /**
+     * Basic integrity check: remove entries with empty/missing data.
+     */
+    async verifyAndRepairModels() {
+        const db = await this.db;
+        let verified = 0;
+        let removed = 0;
+        const tx = db.transaction('models', 'readwrite');
+        for await (const cursor of tx.store) {
+            const m = cursor.value;
+            if (!m.data || m.data.byteLength === 0) {
+                await cursor.delete();
+                removed++;
+            }
+            else {
+                verified++;
+            }
+        }
+        return { verified, repaired: 0, removed };
+    }
+}
+// Singleton + convenience exports, matching other service modules.
+const modelService = new ModelService();
+const downloadModels = (models, styleId, options) => modelService.downloadModels(models, styleId, options);
+const getModel = (styleId, modelName) => modelService.getModel(styleId, modelName);
+const getModelStats = () => modelService.getModelStats();
+const cleanupOldModels = (maxAge) => modelService.cleanupOldModels(maxAge);
+const verifyAndRepairModels = () => modelService.verifyAndRepairModels();
+
+var modelService$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    ModelService: ModelService,
+    cleanupOldModels: cleanupOldModels,
+    downloadModels: downloadModels,
+    getModel: getModel,
+    getModelStats: getModelStats,
+    modelKeyBelongsToStyle: modelKeyBelongsToStyle,
+    modelService: modelService,
+    verifyAndRepairModels: verifyAndRepairModels
+});
+
 class ResourceService {
     // Tile Management Methods
     async downloadTilesWithOptions(region, style, styleId, options = {}) {
@@ -7103,6 +7428,19 @@ class ResourceService {
     async verifyAndRepairGlyphs() {
         return verifyAndRepairGlyphs();
     }
+    // 3D Model Management Methods
+    async downloadModelsWithOptions(models, styleId, options = {}) {
+        return downloadModels(models, styleId, options);
+    }
+    async getModelStats() {
+        return getModelStats();
+    }
+    async cleanupOldModels(options) {
+        return cleanupOldModels(options?.maxAge);
+    }
+    async verifyAndRepairModels() {
+        return verifyAndRepairModels();
+    }
 }
 
 // The underlying stats functions already iterate every entry in their
@@ -7897,6 +8235,10 @@ const createResourceManagement = (services) => ({
     loadGlyphsForStyle: (...args) => services.resourceService.loadGlyphsForStyle(...args),
     cleanupOldGlyphs: (...args) => services.resourceService.cleanupOldGlyphs(...args),
     verifyAndRepairGlyphs: (...args) => services.resourceService.verifyAndRepairGlyphs(...args),
+    downloadModelsWithOptions: (...args) => services.resourceService.downloadModelsWithOptions(...args),
+    getModelStats: (...args) => services.resourceService.getModelStats(...args),
+    cleanupOldModels: (...args) => services.resourceService.cleanupOldModels(...args),
+    verifyAndRepairModels: (...args) => services.resourceService.verifyAndRepairModels(...args),
 });
 
 const createAnalyticsManagement = (services, deps) => ({
@@ -11543,10 +11885,12 @@ class PanelRenderer extends BaseComponent {
                             panelLogger.debug(`Fixed legacy source ${sourceId}: added tiles, removed url`);
                         }
                     }
-                    // Apply maxzoom to all tile sources (including batched-model for 3D buildings)
+                    // Apply maxzoom to all tile sources (including batched-model for 3D
+                    // buildings and raster-array for Mapbox Standard landmark icons).
                     if (src.type === 'vector' ||
                         src.type === 'raster' ||
                         src.type === 'raster-dem' ||
+                        src.type === 'raster-array' ||
                         src.type === 'batched-model') {
                         const originalMaxzoom = src.maxzoom;
                         // Use the lower of region maxZoom and source's original maxzoom so we
@@ -13609,5 +13953,5 @@ class OfflineManagerControl {
     }
 }
 
-export { AnalyticsService, CONTENT_TYPES, CategorizedError, CleanupService, DB_NAME, DB_VERSION, DOWNLOAD_DEFAULTS, ERROR_MESSAGES, ErrorType, FontService, GLYPH_CONFIG, GZIP_MAGIC_BYTES, GlyphService, ImportExportService, LogLevel, MAPBOX_API, MAPBOX_CACHE_TTL, MAPBOX_CLASSIC_STYLES, MAP_PROVIDERS, MaintenanceService, OfflineManagerControl, OfflineMapDBVersionError, OfflineMapManager, RESOURCE_TYPES, RegionService, ResourceService, STORAGE_CONFIG, STORE_NAMES, STYLE_CONFIG, SUCCESS_MESSAGES, ScopedLogger, SpriteService, TILE_CONFIG, TileService, URL_SCHEMES, VALIDATION_PATTERNS, applyProxy, categorizeError, cleanupCompressedTiles, cleanupExpiredTiles, cleanupOldFonts, cleanupOldGlyphs, cleanupOldSprites, cleanupOldStyles, cleanupOldTiles, cleanupService, clearAllCaches, configureLogger, configureProxy, convertStyleForServiceWorker, countCompressedTiles, createProgressTracker, createTileKey, dbPromise, OfflineMapManager as default, deleteStyleById, deleteStyles, deriveTileExtension, detectCssPrefix, detectStyleProvider, downloadFonts, downloadGlyphs, downloadSprites, downloadStyleWithProvider, downloadStyles, downloadTiles, escapeHtml$1 as escapeHtml, extractAccessToken, extractAllFontNames, extractFontNamesFromTextField, fetchResourceWithRetry, fetchWithRetry, fontService, formatBytes, formatDate, generateGlyphUrlsFromStyle, getExpiredResourceCount, getFontAnalytics, getFontStats, getGlyphAnalytics, getGlyphStats, getIcon, getRegionAnalytics, getSpriteAnalytics, getSpriteStats, getStyleStats, getTileAnalytics, getTileStats, getUserErrorMessage, glyphService, hasImports, i18n, icons, idbFetchHandler, isMapboxProtocol, isStyleDownloaded, loadAllStoredRegions, loadGlyphs, loadStyleById, loadStyles, logger, normalizeSpriteProperty, normalizeStyleUrl, optimizeStorage, parseCacheExpiry, parseTileKey, patchStyleForOffline, performCleanup, processBatch, processStyleSources, registerOfflineServiceWorker, resetOfflineMapDB, resolveImports, resolveMapboxUrl, resourceKeyBelongsToStyle, rewriteMapboxCdnTileUrl, safeExecute, setupAutoCleanup, spriteService, stopAutoCleanup, t, tileService, unregisterOfflineServiceWorker, validateBounds, validateRegionOptions, validateResource, validateStyleForProvider, validateZoomLevels, verifyAndRepairFonts, verifyAndRepairGlyphs, verifyAndRepairSprites };
+export { AnalyticsService, CONTENT_TYPES, CategorizedError, CleanupService, DB_NAME, DB_VERSION, DOWNLOAD_DEFAULTS, ERROR_MESSAGES, ErrorType, FontService, GLYPH_CONFIG, GZIP_MAGIC_BYTES, GlyphService, ImportExportService, LogLevel, MAPBOX_API, MAPBOX_CACHE_TTL, MAPBOX_CLASSIC_STYLES, MAP_PROVIDERS, MaintenanceService, ModelService, OfflineManagerControl, OfflineMapDBVersionError, OfflineMapManager, RESOURCE_TYPES, RegionService, ResourceService, STORAGE_CONFIG, STORE_NAMES, STYLE_CONFIG, SUCCESS_MESSAGES, ScopedLogger, SpriteService, TILE_CONFIG, TileService, URL_SCHEMES, VALIDATION_PATTERNS, applyProxy, categorizeError, cleanupCompressedTiles, cleanupExpiredTiles, cleanupOldFonts, cleanupOldGlyphs, cleanupOldModels, cleanupOldSprites, cleanupOldStyles, cleanupOldTiles, cleanupService, clearAllCaches, configureLogger, configureProxy, convertStyleForServiceWorker, countCompressedTiles, createProgressTracker, createTileKey, dbPromise, OfflineMapManager as default, deleteStyleById, deleteStyles, deriveTileExtension, detectCssPrefix, detectStyleProvider, downloadFonts, downloadGlyphs, downloadModels, downloadSprites, downloadStyleWithProvider, downloadStyles, downloadTiles, escapeHtml$1 as escapeHtml, extractAccessToken, extractAllFontNames, extractFontNamesFromTextField, fetchResourceWithRetry, fetchWithRetry, fontService, formatBytes, formatDate, generateGlyphUrlsFromStyle, getExpiredResourceCount, getFontAnalytics, getFontStats, getGlyphAnalytics, getGlyphStats, getIcon, getModel, getModelStats, getRegionAnalytics, getSpriteAnalytics, getSpriteStats, getStyleStats, getTileAnalytics, getTileStats, getUserErrorMessage, glyphService, hasImports, i18n, icons, idbFetchHandler, isMapboxProtocol, isStyleDownloaded, loadAllStoredRegions, loadGlyphs, loadStyleById, loadStyles, logger, modelKeyBelongsToStyle, modelService, normalizeSpriteProperty, normalizeStyleUrl, optimizeStorage, parseCacheExpiry, parseTileKey, patchStyleForOffline, performCleanup, processBatch, processStyleSources, registerOfflineServiceWorker, resetOfflineMapDB, resolveImports, resolveMapboxUrl, resourceKeyBelongsToStyle, rewriteMapboxCdnTileUrl, safeExecute, setupAutoCleanup, spriteService, stopAutoCleanup, t, tileService, unregisterOfflineServiceWorker, validateBounds, validateRegionOptions, validateResource, validateStyleForProvider, validateZoomLevels, verifyAndRepairFonts, verifyAndRepairGlyphs, verifyAndRepairModels, verifyAndRepairSprites };
 //# sourceMappingURL=index.esm.js.map