map-gl-offline 0.1.0-alpha.0

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+import 'maplibre-gl/dist/maplibre-gl.css';
+import 'map-gl-style-switcher/dist/map-gl-style-switcher.css';

package/dist/managers/offlineMapManager/analyticsManagement.d.ts

@@ -0,0 +1,7 @@
+import type { StorageAnalyticsReport } from '../../types';
+import type { OfflineManagerServices } from './base';
+import type { CleanupManagement } from './cleanupManagement';
+export interface AnalyticsManagement {
+    getComprehensiveStorageAnalytics(): Promise<StorageAnalyticsReport>;
+}
+export declare const createAnalyticsManagement: (services: OfflineManagerServices, deps: Pick<CleanupManagement, "getRegionAnalytics">) => AnalyticsManagement;

package/dist/managers/offlineMapManager/base.d.ts

@@ -0,0 +1,14 @@
+import { CleanupService } from '../../services/cleanupService';
+import { RegionService } from '../../services/regionService';
+import { ResourceService } from '../../services/resourceService';
+import { AnalyticsService } from '../../services/analyticsService';
+import { ImportExportService } from '../../services/importExportService';
+export interface OfflineManagerServices {
+    regionService: RegionService;
+    cleanupService: CleanupService;
+    resourceService: ResourceService;
+    analyticsService: AnalyticsService;
+    importExportService: ImportExportService;
+}
+export type OfflineManagerServiceOverrides = Partial<OfflineManagerServices>;
+export declare const createManagerServices: (overrides?: OfflineManagerServiceOverrides) => OfflineManagerServices;

package/dist/managers/offlineMapManager/cleanupManagement.d.ts

@@ -0,0 +1,16 @@
+import type { CleanupResult, RegionAnalytics, RegionCleanupOptions } from '../../types';
+import type { OfflineManagerServices } from './base';
+export interface CleanupManagement {
+    getRegionSize(regionId: string): Promise<number>;
+    cleanupExpiredRegions(): Promise<number>;
+    forceCleanupExpiredRegions(): Promise<number>;
+    setupAutoCleanup(options?: RegionCleanupOptions & {
+        intervalHours?: number;
+    }): Promise<string>;
+    stopAutoCleanup(cleanupId?: string): Promise<void>;
+    getRegionAnalytics(): Promise<RegionAnalytics>;
+    performSmartCleanup(options?: RegionCleanupOptions): Promise<CleanupResult>;
+    startEnhancedAutoCleanup(intervalHours?: number, options?: RegionCleanupOptions): Promise<string>;
+    stopAllAutoCleanup(): Promise<void>;
+}
+export declare const createCleanupManagement: (services: OfflineManagerServices) => CleanupManagement;

package/dist/managers/offlineMapManager/importExportManagement.d.ts

@@ -0,0 +1,10 @@
+import type { ExportResult, ImportExportOptions, ImportResult, PMTilesExportOptions, MBTilesExportOptions, RegionImportData } from '../../types';
+import type { OfflineManagerServices } from './base';
+export interface ImportExportManagement {
+    exportRegionAsJSON(regionId: string, options?: ImportExportOptions): Promise<ExportResult>;
+    exportRegionAsPMTiles(regionId: string, options?: ImportExportOptions & PMTilesExportOptions): Promise<ExportResult>;
+    exportRegionAsMBTiles(regionId: string, options?: ImportExportOptions & MBTilesExportOptions): Promise<ExportResult>;
+    importRegion(importData: RegionImportData): Promise<ImportResult>;
+    downloadExportedRegion(exportResult: ExportResult): void;
+}
+export declare const createImportExportManagement: (services: OfflineManagerServices) => ImportExportManagement;

package/dist/managers/offlineMapManager/index.d.ts

@@ -0,0 +1,72 @@
+import { type OfflineManagerServiceOverrides, type OfflineManagerServices } from './base';
+import { type OfflineMapManagerModules } from './modules';
+import type { RegionManagement } from './regionManagement';
+import type { CleanupManagement } from './cleanupManagement';
+import type { ResourceManagement } from './resourceManagement';
+import type { AnalyticsManagement } from './analyticsManagement';
+import type { MaintenanceManagement } from './maintenanceManagement';
+import type { ImportExportManagement } from './importExportManagement';
+import type { StyleManagement } from './styleManagement';
+export declare class OfflineMapManager implements OfflineMapManagerModules {
+    private readonly services;
+    private readonly modules;
+    addRegion: RegionManagement['addRegion'];
+    loadRegion: RegionManagement['loadRegion'];
+    deleteRegion: RegionManagement['deleteRegion'];
+    listRegions: RegionManagement['listRegions'];
+    listStoredRegions: RegionManagement['listStoredRegions'];
+    getStoredRegion: RegionManagement['getStoredRegion'];
+    getRegionSize: CleanupManagement['getRegionSize'];
+    cleanupExpiredRegions: CleanupManagement['cleanupExpiredRegions'];
+    forceCleanupExpiredRegions: CleanupManagement['forceCleanupExpiredRegions'];
+    setupAutoCleanup: CleanupManagement['setupAutoCleanup'];
+    stopAutoCleanup: CleanupManagement['stopAutoCleanup'];
+    getRegionAnalytics: CleanupManagement['getRegionAnalytics'];
+    performSmartCleanup: CleanupManagement['performSmartCleanup'];
+    startEnhancedAutoCleanup: CleanupManagement['startEnhancedAutoCleanup'];
+    stopAllAutoCleanup: CleanupManagement['stopAllAutoCleanup'];
+    downloadTilesWithOptions: ResourceManagement['downloadTilesWithOptions'];
+    getTileStatistics: ResourceManagement['getTileStatistics'];
+    downloadFontsWithOptions: ResourceManagement['downloadFontsWithOptions'];
+    getFontStatistics: ResourceManagement['getFontStatistics'];
+    getFontAnalytics: ResourceManagement['getFontAnalytics'];
+    cleanupOldFonts: ResourceManagement['cleanupOldFonts'];
+    verifyAndRepairFonts: ResourceManagement['verifyAndRepairFonts'];
+    downloadSpritesWithOptions: ResourceManagement['downloadSpritesWithOptions'];
+    getSpriteStatistics: ResourceManagement['getSpriteStatistics'];
+    cleanupOldSprites: ResourceManagement['cleanupOldSprites'];
+    verifyAndRepairSprites: ResourceManagement['verifyAndRepairSprites'];
+    getSpriteAnalytics: ResourceManagement['getSpriteAnalytics'];
+    downloadGlyphsWithOptions: ResourceManagement['downloadGlyphsWithOptions'];
+    getGlyphStatistics: ResourceManagement['getGlyphStatistics'];
+    getGlyphAnalytics: ResourceManagement['getGlyphAnalytics'];
+    loadGlyphsForStyle: ResourceManagement['loadGlyphsForStyle'];
+    cleanupOldGlyphs: ResourceManagement['cleanupOldGlyphs'];
+    verifyAndRepairGlyphs: ResourceManagement['verifyAndRepairGlyphs'];
+    getComprehensiveStorageAnalytics: AnalyticsManagement['getComprehensiveStorageAnalytics'];
+    performCompleteMaintenance: MaintenanceManagement['performCompleteMaintenance'];
+    exportRegionAsJSON: ImportExportManagement['exportRegionAsJSON'];
+    exportRegionAsPMTiles: ImportExportManagement['exportRegionAsPMTiles'];
+    exportRegionAsMBTiles: ImportExportManagement['exportRegionAsMBTiles'];
+    importRegion: ImportExportManagement['importRegion'];
+    downloadExportedRegion: ImportExportManagement['downloadExportedRegion'];
+    downloadStyle: StyleManagement['downloadStyle'];
+    loadStyleById: StyleManagement['loadStyleById'];
+    listStyles: StyleManagement['listStyles'];
+    deleteStyle: StyleManagement['deleteStyle'];
+    getStyleStats: StyleManagement['getStyleStats'];
+    downloadMapboxStyle: StyleManagement['downloadMapboxStyle'];
+    downloadMapLibreStyle: StyleManagement['downloadMapLibreStyle'];
+    downloadStyleWithAutoDetection: StyleManagement['downloadStyleWithAutoDetection'];
+    cleanupOldStyles: StyleManagement['cleanupOldStyles'];
+    constructor(overrides?: OfflineManagerServiceOverrides);
+    getServices(): OfflineManagerServices;
+    getModules(): OfflineMapManagerModules;
+}
+export declare const createOfflineMapManager: (overrides?: OfflineManagerServiceOverrides) => {
+    services: OfflineManagerServices;
+    modules: OfflineMapManagerModules;
+};
+export type { OfflineManagerServices, OfflineManagerServiceOverrides } from './base';
+export type { OfflineMapManagerModules } from './modules';
+export { createOfflineMapManagerModules } from './modules';

package/dist/managers/offlineMapManager/maintenanceManagement.d.ts

@@ -0,0 +1,13 @@
+import type { MaintenanceOptions, MaintenanceResults } from '../../types';
+import type { OfflineManagerServices } from './base';
+import type { CleanupManagement } from './cleanupManagement';
+import type { RegionManagement } from './regionManagement';
+import type { AnalyticsManagement } from './analyticsManagement';
+export interface MaintenanceManagement {
+    performCompleteMaintenance(options?: MaintenanceOptions): Promise<MaintenanceResults>;
+}
+export declare const createMaintenanceManagement: (services: OfflineManagerServices, deps: {
+    performSmartCleanup: CleanupManagement["performSmartCleanup"];
+    listRegions: RegionManagement["listRegions"];
+    getComprehensiveStorageAnalytics: AnalyticsManagement["getComprehensiveStorageAnalytics"];
+}) => MaintenanceManagement;

package/dist/managers/offlineMapManager/modules.d.ts

@@ -0,0 +1,10 @@
+import type { OfflineManagerServices } from './base';
+import { type RegionManagement } from './regionManagement';
+import { type CleanupManagement } from './cleanupManagement';
+import { type ResourceManagement } from './resourceManagement';
+import { type AnalyticsManagement } from './analyticsManagement';
+import { type MaintenanceManagement } from './maintenanceManagement';
+import { type ImportExportManagement } from './importExportManagement';
+import { type StyleManagement } from './styleManagement';
+export type OfflineMapManagerModules = RegionManagement & CleanupManagement & ResourceManagement & AnalyticsManagement & MaintenanceManagement & ImportExportManagement & StyleManagement;
+export declare const createOfflineMapManagerModules: (services: OfflineManagerServices) => OfflineMapManagerModules;

package/dist/managers/offlineMapManager/regionManagement.d.ts

@@ -0,0 +1,11 @@
+import type { OfflineRegionOptions, StoredRegion } from '../../types';
+import type { OfflineManagerServices } from './base';
+export interface RegionManagement {
+    addRegion(region: OfflineRegionOptions): Promise<void>;
+    loadRegion(region: OfflineRegionOptions): Promise<void>;
+    deleteRegion(regionId: string): Promise<void>;
+    listRegions(): Promise<OfflineRegionOptions[]>;
+    listStoredRegions(): Promise<StoredRegion[]>;
+    getStoredRegion(regionId: string): Promise<StoredRegion | null>;
+}
+export declare const createRegionManagement: (services: OfflineManagerServices) => RegionManagement;

package/dist/managers/offlineMapManager/resourceManagement.d.ts

@@ -0,0 +1,24 @@
+import type { ResourceService } from '../../services/resourceService';
+import type { OfflineManagerServices } from './base';
+export type ResourceServiceMethod<TMethod extends keyof ResourceService> = ResourceService[TMethod];
+export interface ResourceManagement {
+    downloadTilesWithOptions: ResourceService['downloadTilesWithOptions'];
+    getTileStatistics: ResourceService['getTileStatistics'];
+    downloadFontsWithOptions: ResourceService['downloadFontsWithOptions'];
+    getFontStatistics: ResourceService['getFontStatistics'];
+    getFontAnalytics: ResourceService['getFontAnalytics'];
+    cleanupOldFonts: ResourceService['cleanupOldFonts'];
+    verifyAndRepairFonts: ResourceService['verifyAndRepairFonts'];
+    downloadSpritesWithOptions: ResourceService['downloadSpritesWithOptions'];
+    getSpriteStatistics: ResourceService['getSpriteStatistics'];
+    cleanupOldSprites: ResourceService['cleanupOldSprites'];
+    verifyAndRepairSprites: ResourceService['verifyAndRepairSprites'];
+    getSpriteAnalytics: ResourceService['getSpriteAnalytics'];
+    downloadGlyphsWithOptions: ResourceService['downloadGlyphsWithOptions'];
+    getGlyphStatistics: ResourceService['getGlyphStatistics'];
+    getGlyphAnalytics: ResourceService['getGlyphAnalytics'];
+    loadGlyphsForStyle: ResourceService['loadGlyphsForStyle'];
+    cleanupOldGlyphs: ResourceService['cleanupOldGlyphs'];
+    verifyAndRepairGlyphs: ResourceService['verifyAndRepairGlyphs'];
+}
+export declare const createResourceManagement: (services: OfflineManagerServices) => ResourceManagement;

package/dist/managers/offlineMapManager/styleManagement.d.ts

@@ -0,0 +1,17 @@
+import type { EnhancedStyleStats, StyleDownloadOptions, StyleDownloadResult, StyleEntry, StyleProvider } from '../../types';
+export interface StyleManagement {
+    downloadStyle(styleUrl: string, options?: StyleDownloadOptions & {
+        provider?: StyleProvider;
+        accessToken?: string;
+        forceProvider?: boolean;
+    }): Promise<StyleDownloadResult>;
+    loadStyleById(styleId: string): Promise<StyleEntry | null>;
+    listStyles(): Promise<StyleEntry[]>;
+    deleteStyle(styleId: string): Promise<void>;
+    getStyleStats(styleId: string): Promise<EnhancedStyleStats>;
+    downloadMapboxStyle(styleUrl: string, accessToken?: string, options?: StyleDownloadOptions): Promise<StyleDownloadResult>;
+    downloadMapLibreStyle(styleUrl: string, options?: StyleDownloadOptions): Promise<StyleDownloadResult>;
+    downloadStyleWithAutoDetection(styleUrl: string, options?: StyleDownloadOptions): Promise<StyleDownloadResult>;
+    cleanupOldStyles(maxAgeDays?: number): Promise<number>;
+}
+export declare const createStyleManagement: () => StyleManagement;

package/dist/managers/offlineMapManager.d.ts

@@ -0,0 +1,2 @@
+export { OfflineMapManager, createOfflineMapManager, createOfflineMapManagerModules, } from './offlineMapManager/index';
+export type { OfflineManagerServices, OfflineManagerServiceOverrides, OfflineMapManagerModules, } from './offlineMapManager/index';

package/dist/services/analyticsService.d.ts

@@ -0,0 +1,10 @@
+import { EnhancedGlyphStats } from './glyphService';
+import type { RegionAnalytics, TileStats, StorageAnalyticsReport, EnhancedFontStats, EnhancedSpriteStats } from '../types/';
+export declare class AnalyticsService {
+    getAllTileStats(): Promise<TileStats>;
+    getAllFontStats(): Promise<EnhancedFontStats>;
+    getAllSpriteStats(): Promise<EnhancedSpriteStats>;
+    getAllGlyphStats(): Promise<EnhancedGlyphStats>;
+    getComprehensiveStorageAnalytics(getRegionAnalytics: () => Promise<RegionAnalytics>): Promise<StorageAnalyticsReport>;
+    private generateStorageRecommendations;
+}

package/dist/services/baseDownloadService.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Base class for download services
+ * Provides common functionality for tile, glyph, sprite, and font downloads
+ */
+import type { DownloadProgress } from '../types';
+/**
+ * Base options for all download services
+ */
+export interface BaseDownloadOptions {
+    /** Progress callback */
+    onProgress?: (progress: DownloadProgress) => void;
+    /** Number of items to process concurrently */
+    batchSize?: number;
+    /** Maximum retry attempts */
+    maxRetries?: number;
+    /** Skip items that already exist */
+    skipExisting?: boolean;
+    /** Request timeout in milliseconds */
+    timeout?: number;
+    /** Delay between retries in milliseconds */
+    retryDelay?: number;
+    /** Check storage quota before download */
+    storageQuotaCheck?: boolean;
+}
+/**
+ * Base result for all download operations
+ */
+export interface BaseDownloadResult {
+    /** Total items in download plan */
+    total: number;
+    /** Successfully downloaded items */
+    downloaded: number;
+    /** Items skipped (already exist) */
+    skipped: number;
+    /** Failed downloads */
+    failed: number;
+    /** Total size in bytes */
+    totalSize: number;
+    /** Download duration in milliseconds */
+    downloadTime: number;
+    /** Average download speed in KB/s */
+    averageSpeed: number;
+    /** Error details */
+    errors: Array<{
+        url: string;
+        error: string;
+    }>;
+}
+/**
+ * Base download service with common functionality
+ */
+export declare abstract class BaseDownloadService {
+    protected abstract serviceName: string;
+    /**
+     * Get a scoped logger for this service
+     */
+    protected getLogger(): import("..").ScopedLogger;
+    /**
+     * Check storage quota before download
+     * @param requiredSpace - Estimated space needed in bytes
+     * @throws Error if insufficient space
+     */
+    protected checkStorageQuota(requiredSpace?: number): Promise<void>;
+    /**
+     * Calculate average speed in KB/s
+     */
+    protected calculateSpeed(bytes: number, milliseconds: number): number;
+    /**
+     * Create a standardized error object
+     */
+    protected createError(url: string, error: unknown): {
+        url: string;
+        error: string;
+    };
+    /**
+     * Sleep for a specified duration
+     */
+    protected sleep(ms: number): Promise<void>;
+    /**
+     * Track download statistics
+     */
+    protected createStatsTracker(): {
+        trackItem(name: string, size: number, type?: string): void;
+        getStats(): {
+            largest: {
+                name: string;
+                size: number;
+            } | undefined;
+            smallest: {
+                name: string;
+                size: number;
+            } | undefined;
+            byType: Record<string, number>;
+        };
+    };
+}

package/dist/services/cleanupService.d.ts

@@ -0,0 +1,34 @@
+import type { StoredRegion, RegionCleanupOptions, CleanupResult, RegionAnalytics } from '../types';
+export declare class CleanupService {
+    private db;
+    private deleteRegionCallback;
+    private autoCleanupIntervals;
+    constructor(deleteRegionCallback: (regionId: string, styleId?: string) => Promise<void>);
+    runCleanup(options?: RegionCleanupOptions): Promise<CleanupResult>;
+    performCleanup(options?: RegionCleanupOptions): Promise<CleanupResult>;
+    getRegionAnalytics(): Promise<RegionAnalytics>;
+    setupAutoCleanup(options?: RegionCleanupOptions & {
+        intervalHours?: number;
+    }): Promise<string>;
+    stopAutoCleanup(cleanupId?: string): Promise<void>;
+    optimizeStorage(): Promise<{
+        compactedSize: number;
+        freedSpace: number;
+    }>;
+    getAllRegions(): Promise<StoredRegion[]>;
+    getRegionSize(regionId: string): Promise<number>;
+    private calculateTotalStorageSize;
+    private selectRegionsForDeletion;
+    private generateRecommendations;
+}
+export declare const cleanupService: CleanupService;
+export declare const performCleanup: (options?: RegionCleanupOptions) => Promise<CleanupResult>;
+export declare const getRegionAnalytics: () => Promise<RegionAnalytics>;
+export declare const setupAutoCleanup: (options?: RegionCleanupOptions & {
+    intervalHours?: number;
+}) => Promise<string>;
+export declare const stopAutoCleanup: (cleanupId?: string) => Promise<void>;
+export declare const optimizeStorage: () => Promise<{
+    compactedSize: number;
+    freedSpace: number;
+}>;

package/dist/services/fontService.d.ts

@@ -0,0 +1,26 @@
+import type { EnhancedFontStats, FontDownloadOptions, FontDownloadResult } from '../types';
+export declare class FontService {
+    private db;
+    downloadFonts(fontUrls: string[], styleName?: string, options?: FontDownloadOptions): Promise<FontDownloadResult>;
+    getFontStats(): Promise<EnhancedFontStats>;
+    getFontAnalytics(): Promise<Record<string, unknown>>;
+    cleanupOldFonts(maxAge?: number): Promise<number>;
+    verifyAndRepairFonts(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+    private createFontKey;
+    private detectFontType;
+    private validateFont;
+}
+export declare const fontService: FontService;
+export declare const downloadFonts: (fontUrls: string[], styleName?: string, options?: FontDownloadOptions) => Promise<FontDownloadResult>;
+export declare const getFontStats: () => Promise<EnhancedFontStats>;
+export declare const getFontAnalytics: () => Promise<Record<string, unknown>>;
+export declare const cleanupOldFonts: (maxAge?: number) => Promise<number>;
+export declare const verifyAndRepairFonts: () => Promise<{
+    verified: number;
+    repaired: number;
+    removed: number;
+}>;

package/dist/services/glyphService.d.ts

@@ -0,0 +1,58 @@
+import type { GlyphDownloadOptions, GlyphDownloadResult, GlyphEntry, GlyphRange } from '../types';
+export interface EnhancedGlyphStats {
+    count: number;
+    totalSize: number;
+    averageSize: number;
+    glyphs: Array<{
+        fontstack: string;
+        range: string;
+        size: number;
+        lastModified: number;
+        metadata?: Record<string, unknown>;
+    }>;
+    fontsByStack: Record<string, number>;
+    sizeByStack: Record<string, number>;
+    oldestGlyph?: {
+        fontstack: string;
+        range: string;
+        lastModified: number;
+    };
+    newestGlyph?: {
+        fontstack: string;
+        range: string;
+        lastModified: number;
+    };
+    corruptedGlyphs: string[];
+}
+export declare class GlyphService {
+    private db;
+    downloadGlyphs(glyphUrl: string, fontstacks: string[], styleName?: string, ranges?: string[], options?: GlyphDownloadOptions): Promise<GlyphDownloadResult>;
+    loadGlyphs(fontstack: string, ranges: string[], styleName?: string): Promise<GlyphRange[]>;
+    getGlyph(fontstack: string, range: string, styleName?: string): Promise<GlyphEntry | null>;
+    getGlyphStats(): Promise<EnhancedGlyphStats>;
+    getGlyphAnalytics(): Promise<Record<string, unknown>>;
+    cleanupOldGlyphs(maxAge?: number): Promise<number>;
+    verifyAndRepairGlyphs(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+    private validateGlyphData;
+    private countGlyphsInData;
+    private calculateCompressionRatio;
+    private normalizeFontstack;
+    private buildGlyphPath;
+    private parseGlyphKey;
+    private createGlyphKey;
+}
+export declare const glyphService: GlyphService;
+export declare const downloadGlyphs: (glyphUrl: string, fontstacks: string[], styleName?: string, ranges?: string[], options?: GlyphDownloadOptions) => Promise<GlyphDownloadResult>;
+export declare const loadGlyphs: (fontstack: string, ranges: string[], styleName?: string) => Promise<GlyphRange[]>;
+export declare const getGlyphStats: () => Promise<EnhancedGlyphStats>;
+export declare const getGlyphAnalytics: () => Promise<Record<string, unknown>>;
+export declare const cleanupOldGlyphs: (maxAge?: number) => Promise<number>;
+export declare const verifyAndRepairGlyphs: () => Promise<{
+    verified: number;
+    repaired: number;
+    removed: number;
+}>;

package/dist/services/importExportService.d.ts

@@ -0,0 +1,57 @@
+import type { RegionImportData, ImportExportOptions, ImportResult, ExportResult, PMTilesExportOptions, MBTilesExportOptions } from '../types';
+export declare class ImportExportService {
+    private db;
+    constructor();
+    /**
+     * Export a region to JSON format
+     */
+    exportRegionAsJSON(regionId: string, options?: ImportExportOptions): Promise<ExportResult>;
+    /**
+     * Export region as PMTiles format
+     */
+    exportRegionAsPMTiles(regionId: string, options?: ImportExportOptions & PMTilesExportOptions): Promise<ExportResult>;
+    /**
+     * Export region as MBTiles format
+     */
+    exportRegionAsMBTiles(regionId: string, options?: ImportExportOptions & MBTilesExportOptions): Promise<ExportResult>;
+    /**
+     * Import region from file
+     */
+    importRegion(importData: RegionImportData): Promise<ImportResult>;
+    /**
+     * Get region metadata
+     */
+    private getRegionMetadata;
+    /**
+     * Export style data
+     */
+    private exportStyle;
+    /**
+     * Export tiles data
+     */
+    private exportTiles;
+    /**
+     * Export sprites data
+     */
+    private exportSprites;
+    /**
+     * Export fonts data
+     */
+    private exportFonts;
+    /**
+     * Read file content
+     */
+    private readFileContent;
+    /**
+     * Parse PMTiles file (simplified)
+     */
+    private parsePMTiles;
+    /**
+     * Parse MBTiles file (simplified)
+     */
+    private parseMBTiles;
+    /**
+     * Import region data to database
+     */
+    private importRegionData;
+}

package/dist/services/maintenanceService.d.ts

@@ -0,0 +1,15 @@
+import type { StorageAnalyticsReport, MaintenanceOptions, MaintenanceResults, RegionCleanupOptions, CleanupResult } from '../types';
+export type { MaintenanceOptions, MaintenanceResults } from '../types/maintenance';
+export declare class MaintenanceService {
+    private performSmartCleanup;
+    private listRegions;
+    private verifyAndRepairFonts;
+    private verifyAndRepairSprites;
+    private verifyAndRepairGlyphs;
+    private cleanupOldFonts;
+    private cleanupOldSprites;
+    private cleanupOldGlyphs;
+    private getComprehensiveStorageAnalytics;
+    constructor(performSmartCleanup: (options?: RegionCleanupOptions) => Promise<CleanupResult>, listRegions: () => Promise<unknown[]>, verifyAndRepairFonts: (styleId: string, options?: Record<string, unknown>) => Promise<unknown>, verifyAndRepairSprites: (styleId: string, options?: Record<string, unknown>) => Promise<unknown>, verifyAndRepairGlyphs: (styleId: string, options?: Record<string, unknown>) => Promise<unknown>, cleanupOldFonts: (options?: Record<string, unknown>) => Promise<unknown>, cleanupOldSprites: (styleId: string, options?: Record<string, unknown>) => Promise<unknown>, cleanupOldGlyphs: (options?: Record<string, unknown>) => Promise<unknown>, getComprehensiveStorageAnalytics: () => Promise<StorageAnalyticsReport>);
+    performCompleteMaintenance(options?: MaintenanceOptions): Promise<MaintenanceResults>;
+}

package/dist/services/regionService.d.ts

@@ -0,0 +1,31 @@
+import type { OfflineRegionOptions, StoredRegion } from '../types/region';
+export declare class RegionService {
+    /**
+     * Check if a tile overlaps with any region bounds
+     */
+    private tileOverlapsWithRegion;
+    /**
+     * Check if a tile overlaps with any of the given regions
+     */
+    private tileOverlapsWithAnyRegion;
+    /**
+     * Delete tiles that don't overlap with any remaining regions
+     */
+    private deleteNonOverlappingTiles;
+    /**
+     * Delete all resources for a style (fonts, glyphs, sprites)
+     */
+    private deleteStyleResources;
+    /**
+     * Delete all tiles for a style
+     */
+    private deleteAllStyleTiles;
+    addRegion(region: OfflineRegionOptions): Promise<void>;
+    loadRegion(region: OfflineRegionOptions): Promise<void>;
+    deleteRegion(regionId: string): Promise<void>;
+    listRegions(): Promise<OfflineRegionOptions[]>;
+    /**
+     * List all stored regions from styles (used for UI and fitBounds)
+     */
+    listStoredRegions(): Promise<StoredRegion[]>;
+}

package/dist/services/resourceService.d.ts

@@ -0,0 +1,42 @@
+import { EnhancedGlyphStats } from './glyphService';
+import type { OfflineRegionOptions, MapboxStyle, TileDownloadOptions, TileDownloadResult, TileStats, SpriteDownloadOptions, SpriteDownloadResult, EnhancedSpriteStats, FontDownloadOptions, FontDownloadResult, EnhancedFontStats, GlyphDownloadOptions, GlyphDownloadResult } from '../types';
+export declare class ResourceService {
+    downloadTilesWithOptions(region: OfflineRegionOptions, style: MapboxStyle, styleId: string, options?: TileDownloadOptions): Promise<TileDownloadResult>;
+    getTileStatistics(styleId?: string): Promise<TileStats>;
+    getTileAnalytics(styleId?: string): Promise<Record<string, unknown>>;
+    cleanupOldTiles(maxAge?: number, styleId?: string): Promise<number>;
+    downloadFontsWithOptions(fontUrls: string[], downloadId?: string, options?: FontDownloadOptions): Promise<FontDownloadResult>;
+    getFontStatistics(): Promise<EnhancedFontStats>;
+    getFontAnalytics(): Promise<Record<string, unknown>>;
+    cleanupOldFonts(styleId?: string, options?: {
+        maxAge?: number;
+    }): Promise<number>;
+    verifyAndRepairFonts(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+    downloadSpritesWithOptions(spriteUrls: string[], styleName: string, options?: SpriteDownloadOptions): Promise<SpriteDownloadResult>;
+    getSpriteStatistics(): Promise<EnhancedSpriteStats>;
+    getSpriteAnalytics(): Promise<Record<string, unknown>>;
+    cleanupOldSprites(styleId?: string, options?: {
+        maxAge?: number;
+    }): Promise<number>;
+    verifyAndRepairSprites(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+    downloadGlyphsWithOptions(glyphUrl: string, fontstacks: string[], styleName: string, ranges?: string[], options?: GlyphDownloadOptions): Promise<GlyphDownloadResult>;
+    getGlyphStatistics(): Promise<EnhancedGlyphStats>;
+    getGlyphAnalytics(): Promise<Record<string, unknown>>;
+    loadGlyphsForStyle(fontstack: string, ranges: string[], styleId?: string): Promise<import("..").GlyphRange[]>;
+    cleanupOldGlyphs(styleId?: string, options?: {
+        maxAge?: number;
+    }): Promise<number>;
+    verifyAndRepairGlyphs(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+}

package/dist/services/spriteService.d.ts

@@ -0,0 +1,30 @@
+import type { EnhancedSpriteStats, SpriteDownloadOptions, SpriteDownloadResult } from '../types';
+export declare class SpriteService {
+    private db;
+    downloadSprites(spriteUrls: string[], styleName: string, options?: SpriteDownloadOptions): Promise<SpriteDownloadResult>;
+    getSpriteStats(): Promise<EnhancedSpriteStats>;
+    getSpriteAnalytics(): Promise<Record<string, unknown>>;
+    cleanupOldSprites(maxAge?: number): Promise<number>;
+    verifyAndRepairSprites(): Promise<{
+        verified: number;
+        repaired: number;
+        removed: number;
+    }>;
+    private createSpriteKey;
+    private extractSpriteName;
+    private detectSpriteType;
+    private validateSprite;
+    private extractSpriteMetadata;
+    private isProbablySpritesheet;
+    private rateLimitDelay;
+}
+export declare const spriteService: SpriteService;
+export declare const downloadSprites: (spriteUrls: string[], styleName: string, options?: SpriteDownloadOptions) => Promise<SpriteDownloadResult>;
+export declare const getSpriteStats: () => Promise<EnhancedSpriteStats>;
+export declare const getSpriteAnalytics: () => Promise<Record<string, unknown>>;
+export declare const cleanupOldSprites: (maxAge?: number) => Promise<number>;
+export declare const verifyAndRepairSprites: () => Promise<{
+    verified: number;
+    repaired: number;
+    removed: number;
+}>;