map-gl-offline 0.1.0-alpha.0

package/dist/types/import-export.d.ts

@@ -0,0 +1,96 @@
+export interface RegionExportData {
+    metadata: {
+        id: string;
+        name: string;
+        description?: string;
+        bounds: [[number, number], [number, number]];
+        minZoom: number;
+        maxZoom: number;
+        styleUrl: string;
+        createdAt: number;
+        exportedAt: number;
+        version: string;
+        format: 'json' | 'pmtiles' | 'mbtiles';
+    };
+    style: unknown;
+    tiles: TileExportData[];
+    sprites: SpriteExportData[];
+    fonts: FontExportData[];
+}
+export interface TileExportData {
+    z: number;
+    x: number;
+    y: number;
+    data: ArrayBuffer;
+    format: 'pbf' | 'png' | 'jpg' | 'webp';
+    sourceId: string;
+}
+export interface SpriteExportData {
+    url: string;
+    data: ArrayBuffer;
+    type: 'json' | 'png';
+    resolution: '1x' | '2x';
+}
+export interface FontExportData {
+    fontStack: string;
+    range: string;
+    data: ArrayBuffer;
+}
+export interface PMTilesExportOptions {
+    compression?: 'gzip' | 'brotli' | 'none';
+    clustered?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface MBTilesExportOptions {
+    format?: 'pbf' | 'png' | 'jpg';
+    compression?: 'gzip' | 'none';
+    metadata?: Record<string, unknown>;
+}
+export interface ImportExportOptions {
+    includeStyle?: boolean;
+    includeTiles?: boolean;
+    includeSprites?: boolean;
+    includeFonts?: boolean;
+    format?: 'json' | 'pmtiles' | 'mbtiles';
+    compression?: boolean;
+    onProgress?: (progress: ImportExportProgress) => void;
+}
+export interface ImportExportProgress {
+    stage: 'preparing' | 'exporting' | 'importing' | 'processing' | 'complete';
+    percentage: number;
+    message: string;
+    currentItem?: string;
+    totalItems?: number;
+    completedItems?: number;
+}
+export interface RegionImportData {
+    file: File;
+    format: 'json' | 'pmtiles' | 'mbtiles';
+    overwrite?: boolean;
+    newRegionId?: string;
+    newRegionName?: string;
+}
+export interface ImportResult {
+    success: boolean;
+    regionId: string;
+    message: string;
+    warnings?: string[];
+    statistics: {
+        tilesImported: number;
+        spritesImported: number;
+        fontsImported: number;
+        totalSize: number;
+    };
+}
+export interface ExportResult {
+    success: boolean;
+    format: 'json' | 'pmtiles' | 'mbtiles';
+    filename: string;
+    blob: Blob;
+    size: number;
+    statistics: {
+        tilesExported: number;
+        spritesExported: number;
+        fontsExported: number;
+    };
+}

package/dist/types/index.d.ts

@@ -0,0 +1,12 @@
+export * from './region';
+export * from './style';
+export * from './font';
+export * from './tile';
+export * from './sprite';
+export * from './glyph';
+export * from './database';
+export * from './maintenance';
+export * from './progress';
+export * from './cleanup';
+export * from './ui';
+export * from './import-export';

package/dist/types/maintenance.d.ts

@@ -0,0 +1,49 @@
+import { EnhancedGlyphStats } from '../services/glyphService';
+import { TileStats } from './tile';
+import { EnhancedFontStats } from './font';
+import { EnhancedSpriteStats } from './sprite';
+import { CleanupResult, RegionAnalytics } from './cleanup';
+export interface MaintenanceOptions {
+    cleanupExpired?: boolean;
+    verifyIntegrity?: boolean;
+    optimizeStorage?: boolean;
+    generateReport?: boolean;
+    onProgress?: (stage: string, progress: number) => void;
+}
+export interface StorageAnalyticsReport {
+    tiles: TileStats;
+    fonts: EnhancedFontStats;
+    sprites: EnhancedSpriteStats;
+    glyphs: EnhancedGlyphStats;
+    regions: RegionAnalytics;
+    totalStorageSize: number;
+    storageByType: Record<string, number>;
+    recommendations: string[];
+}
+export interface MaintenanceResults {
+    cleanupResults?: CleanupResult;
+    integrityResults?: {
+        tiles: {
+            errors: number;
+            fixed: number;
+        };
+        fonts: {
+            corrupted: number;
+            repaired: number;
+        };
+        sprites: {
+            corrupted: number;
+            repaired: number;
+        };
+        glyphs: {
+            corrupted: number;
+            repaired: number;
+        };
+    };
+    optimizationResults?: {
+        freedSpace: number;
+        optimizedResources: number;
+    };
+    analyticsReport?: StorageAnalyticsReport;
+    totalTimeMs: number;
+}

package/dist/types/progress.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Download progress tracking interface
+ */
+export interface DownloadProgress {
+    completed: number;
+    total: number;
+    percentage: number;
+    currentItem?: string;
+    message?: string;
+    errors: string[];
+}

package/dist/types/region.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Stored region with metadata
+ * Extends OfflineRegionOptions with database-specific fields
+ */
+export interface StoredRegion extends OfflineRegionOptions {
+    /** Database key for the region */
+    key: string;
+    /** Associated style ID */
+    styleId: string;
+    /** Creation timestamp (ms since epoch) */
+    created: number;
+    /** Expiry timestamp (ms since epoch) */
+    expiry: number;
+    /** Last modification timestamp (ms since epoch) */
+    lastModified: number;
+    /** Actual tile extension used (mvt, pbf, png, jpg, etc.) */
+    tileExtension?: string;
+}
+/**
+ * Configuration options for an offline region
+ */
+export interface OfflineRegionOptions {
+    /**
+     * Region ID (unique for each region, used as the key in the regions table)
+     */
+    id: string;
+    /** Human-readable region name */
+    name: string;
+    /** Geographic bounds: [[west, south], [east, north]] */
+    bounds: [[number, number], [number, number]];
+    /** Whether this region is part of a multi-region download */
+    multipleRegions?: boolean;
+    /** URL to the map style JSON */
+    styleUrl?: string;
+    /** Minimum zoom level to download */
+    minZoom: number;
+    /** Maximum zoom level to download */
+    maxZoom: number;
+    /** Associated style ID */
+    styleId?: string;
+    /** Download session ID */
+    downloadId?: string;
+    /** Creation timestamp (ms since epoch) */
+    created?: number;
+    /** Last update timestamp (ms since epoch) */
+    updated?: number;
+    /**
+     * Expiry timestamp (ms since epoch)
+     */
+    expiry?: number;
+    /**
+     * Whether to automatically delete this region when it expires (default: false)
+     */
+    deleteOnExpiry?: boolean;
+    /** The actual tile extension used (mvt, pbf, png, jpg, etc.) */
+    tileExtension?: string;
+}

package/dist/types/sprite.d.ts

@@ -0,0 +1,172 @@
+import { DownloadProgress } from './progress';
+/**
+ * Sprite entry stored in IndexedDB
+ */
+export interface SpriteEntry {
+    /** Unique identifier for the sprite (e.g., "style-name@2x.json") */
+    key: string;
+    /** Raw sprite data (image or JSON) in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** MIME type from HTTP Content-Type header */
+    contentType?: string;
+    /** Last-Modified timestamp from HTTP headers (milliseconds since epoch) */
+    lastModified: number;
+    /** ISO 8601 timestamp when sprite was downloaded */
+    downloadedAt: string;
+    /** Sprite file size in bytes */
+    size: number;
+    /** Final URL used for download */
+    url: string;
+    /** Optional identifier linking sprite to a style */
+    styleId?: string;
+    /** Optional identifier linking this sprite to a specific download batch */
+    downloadId?: string;
+    /** Human-readable sprite name */
+    spriteName?: string;
+    /** Additional metadata about the sprite */
+    metadata?: {
+        /** Sprite resolution variant (e.g., "1x", "2x") */
+        variant?: '1x' | '2x' | string;
+        /** Original URL before any transformations */
+        originalUrl?: string;
+    };
+}
+/**
+ * Configuration options for sprite downloads
+ */
+export interface SpriteDownloadOptions {
+    /** Callback for progress updates */
+    onProgress?: (progress: DownloadProgress) => void;
+    /** Number of sprites to download concurrently (default: 10) */
+    batchSize?: number;
+    /** Maximum retry attempts for failed downloads (default: 3) */
+    maxRetries?: number;
+    /** Skip sprites that already exist in storage (default: true) */
+    skipExisting?: boolean;
+    /** Download speed limit in bytes per second */
+    bandwidthLimit?: number;
+    /** Array of sprite keys to download first */
+    prioritySprites?: string[];
+    /** Check storage quota before starting download (default: true) */
+    storageQuotaCheck?: boolean;
+    /** Validate sprite data after download (default: true) */
+    enableValidation?: boolean;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeoutMs?: number;
+    /** Include additional metadata in stored sprites (default: false) */
+    includeMetadata?: boolean;
+}
+/**
+ * Result of a sprite download operation
+ */
+export interface SpriteDownloadResult {
+    /** Total number of sprites in download plan */
+    totalSprites: number;
+    /** Number of sprites successfully downloaded */
+    downloadedSprites: number;
+    /** Number of sprites skipped (already existed) */
+    skippedSprites: number;
+    /** Number of sprites that failed to download */
+    failedSprites: number;
+    /** Total size of all downloaded sprites in bytes */
+    totalSize: number;
+    /** Average download speed in bytes per second */
+    downloadSpeed: number;
+    /** Total download time in milliseconds */
+    duration: number;
+    /** Array of error details for failed downloads */
+    errors: Array<{
+        url: string;
+        error: string;
+    }>;
+    /** Detailed analytics about downloaded sprites */
+    analytics: {
+        /** Distribution by file type (e.g., {"png": 20, "json": 4}) */
+        spritesByType: Record<string, number>;
+        /** Average sprite size in bytes */
+        averageSpriteSize: number;
+        /** Largest sprite details */
+        largestSprite: {
+            name: string;
+            size: number;
+        };
+        /** Smallest sprite details */
+        smallestSprite: {
+            name: string;
+            size: number;
+        };
+    };
+}
+/**
+ * Enhanced statistics about stored sprites
+ */
+export interface EnhancedSpriteStats {
+    /** Total number of stored sprites */
+    count: number;
+    /** Total storage size in bytes */
+    totalSize: number;
+    /** Average sprite size in bytes */
+    averageSize: number;
+    /** Array of sprite details */
+    sprites: Array<{
+        /** Sprite name */
+        name: string;
+        /** Sprite size in bytes */
+        size: number;
+        /** File type */
+        type: string;
+        /** Last modification timestamp */
+        lastModified?: number;
+        /** Additional metadata */
+        metadata?: Record<string, unknown>;
+    }>;
+    /** Distribution by file type */
+    spritesByType: Record<string, number>;
+    /** Total size by file type */
+    sizeByType: Record<string, number>;
+    /** Oldest sprite in storage */
+    oldestSprite?: {
+        name: string;
+        lastModified: number;
+    };
+    /** Newest sprite in storage */
+    newestSprite?: {
+        name: string;
+        lastModified: number;
+    };
+    /** Array of sprite keys that failed validation */
+    corruptedSprites: string[];
+}
+/**
+ * Local sprite entry with additional metadata
+ */
+export interface LocalSpriteEntry {
+    /** Unique identifier for the sprite */
+    key: string;
+    /** Human-readable sprite name */
+    name: string;
+    /** Source URL */
+    url: string;
+    /** Raw sprite data in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** MIME type */
+    contentType: string;
+    /** Sprite file size in bytes */
+    size: number;
+    /** Last modification timestamp (milliseconds since epoch) */
+    lastModified: number;
+    /** Extended metadata */
+    metadata?: {
+        /** Image dimensions if applicable */
+        dimensions?: {
+            width: number;
+            height: number;
+        };
+        /** Image format (e.g., "PNG", "JPEG") */
+        format?: string;
+        /** Compression ratio if compressed */
+        compressionRatio?: number;
+        /** Whether this is a spritesheet */
+        spritesheet?: boolean;
+    };
+}

package/dist/types/style.d.ts

@@ -0,0 +1,103 @@
+import { FontDownloadOptions, FontDownloadResult } from './font';
+import { DownloadProgress } from './progress';
+import { SpriteDownloadOptions, SpriteDownloadResult } from './sprite';
+export type StyleProvider = 'mapbox' | 'maplibre' | 'auto';
+export interface BaseStyle {
+    version: number;
+    name?: string;
+    metadata?: Record<string, unknown>;
+    sources: Record<string, unknown>;
+    layers: unknown[];
+    sprite?: string;
+    glyphs?: string;
+    [key: string]: unknown;
+}
+export interface MapboxGLStyle extends BaseStyle {
+    owner?: string;
+    id?: string;
+    crs?: string;
+    draft?: boolean;
+    created?: string;
+    modified?: string;
+    visibility?: 'public' | 'private';
+}
+export interface MapboxStyle extends BaseStyle {
+    provider?: 'mapbox';
+}
+export type StyleEntry = {
+    key: string;
+    style: BaseStyle;
+    provider: StyleProvider;
+    regions: import('./region').OfflineRegionOptions[];
+    fonts: string[];
+    glyphs: string[];
+    sprites: string[];
+    accessToken?: string;
+    originalUrl?: string;
+};
+export interface StyleDownloadOptions {
+    onProgress?: (progress: DownloadProgress) => void;
+    fontOptions?: FontDownloadOptions;
+    spriteOptions?: SpriteDownloadOptions;
+    skipExisting?: boolean;
+    validateStyle?: boolean;
+    maxRetries?: number;
+    timeoutMs?: number;
+    enableSourceEmbedding?: boolean;
+    storageQuotaCheck?: boolean;
+    includeMetadata?: boolean;
+}
+export interface StyleDownloadResult {
+    styleId: string;
+    success: boolean;
+    downloadTime: number;
+    styleSize: number;
+    sourcesProcessed: number;
+    sourcesEmbedded: number;
+    fontResult?: FontDownloadResult;
+    spriteResult?: SpriteDownloadResult;
+    errors: string[];
+    analytics: {
+        sourceTypes: Record<string, number>;
+        layerTypes: Record<string, number>;
+        totalLayers: number;
+        hasGlyphs: boolean;
+        hasSprites: boolean;
+    };
+}
+export interface EnhancedStyleStats {
+    count: number;
+    totalSize: number;
+    averageSize: number;
+    styles: Array<{
+        id: string;
+        name?: string;
+        size: number;
+        lastModified?: number;
+        sourceCount: number;
+        layerCount: number;
+        hasGlyphs: boolean;
+        hasSprites: boolean;
+        metadata?: Record<string, unknown>;
+    }>;
+    sourceTypes: Record<string, number>;
+    layerTypes: Record<string, number>;
+    oldestStyle?: {
+        id: string;
+        lastModified: number;
+    };
+    newestStyle?: {
+        id: string;
+        lastModified: number;
+    };
+    largestStyle?: {
+        id: string;
+        size: number;
+    };
+    smallestStyle?: {
+        id: string;
+        size: number;
+    };
+    storageRecommendations: string[];
+}
+export type StyleStorageItem = StyleEntry;

package/dist/types/tile.d.ts

@@ -0,0 +1,112 @@
+import type { DownloadProgress } from './progress';
+/**
+ * Tile entry stored in IndexedDB
+ * Represents a single map tile with all its metadata
+ */
+export interface TileEntry {
+    /** Unique key: styleId:sourceId:z:x:y.ext (includes extension) */
+    key: string;
+    /** Tile data as ArrayBuffer */
+    data: ArrayBuffer;
+    /** Download timestamp (ISO string) */
+    downloadedAt: string;
+    /** Size in bytes */
+    size: number;
+    /** Tile type: 'raster' or 'vector' */
+    type: string;
+    /** File format: 'pbf', 'mvt', 'png', 'jpg', 'webp', etc. */
+    format?: string;
+    /** Original download URL */
+    url: string;
+    /** Last modification timestamp (ms since epoch) */
+    lastModified: number;
+    /** HTTP Content-Type header */
+    contentType?: string;
+    /** HTTP Content-Encoding header */
+    contentEncoding?: string;
+    /** Tile X coordinate */
+    x?: number;
+    /** Tile Y coordinate */
+    y?: number;
+    /** Tile zoom level */
+    z?: number;
+    /** Associated style ID */
+    styleId?: string;
+    /** Associated source ID */
+    sourceId?: string;
+}
+/**
+ * Options for tile download operations
+ */
+export interface TileDownloadOptions {
+    /** Progress callback function */
+    onProgress?: (progress: DownloadProgress) => void;
+    /** Number of tiles to download concurrently (default: 10) */
+    batchSize?: number;
+    /** Maximum retry attempts for failed downloads (default: 3) */
+    maxRetries?: number;
+    /** Skip already downloaded tiles (default: true) */
+    skipExisting?: boolean;
+    /** Maximum concurrent download connections (default: 5) */
+    maxConcurrency?: number;
+    /** Delay between retries in ms (default: 1000) */
+    retryDelay?: number;
+    /** Request timeout in ms (default: 10000) */
+    timeout?: number;
+    /** Validate tile data after download (default: false) */
+    validateTiles?: boolean;
+    /** Compress tiles before storage (default: false) */
+    compressTiles?: boolean;
+    /** Priority zoom levels to download first */
+    priorityZoomLevels?: number[];
+    /** Bandwidth limit in KB/s */
+    bandwidthLimit?: number;
+    /** Check storage quota before download (default: true) */
+    storageQuotaCheck?: boolean;
+}
+/**
+ * Result of a tile download operation
+ */
+export interface TileDownloadResult {
+    /** Total tiles in download plan */
+    totalTiles: number;
+    /** Successfully downloaded tiles */
+    downloadedTiles: number;
+    /** Tiles skipped (already exist) */
+    skippedTiles: number;
+    /** Failed tile downloads */
+    failedTiles: number;
+    /** Total download size in bytes */
+    totalSize: number;
+    /** Download duration in ms */
+    downloadTime: number;
+    /** Average download speed in KB/s */
+    averageSpeed: number;
+    /** Array of error details */
+    errors: Array<{
+        url: string;
+        error: string;
+    }>;
+    /** Actual tile extension used (mvt, pbf, png, jpg, etc.) */
+    tileExtension?: string;
+}
+/**
+ * Statistics for stored tiles
+ */
+export interface TileStats {
+    /** Total number of tiles */
+    count: number;
+    /** Total storage size in bytes */
+    totalSize: number;
+    /** Average tile size in bytes */
+    averageSize: number;
+    /** Oldest tile timestamp */
+    oldestTile?: Date;
+    /** Newest tile timestamp */
+    newestTile?: Date;
+    /** Statistics per zoom level */
+    zoomLevelStats: Map<number, {
+        count: number;
+        size: number;
+    }>;
+}

package/dist/types/ui.d.ts

@@ -0,0 +1,10 @@
+export type DownloadOptions = {
+    onProgress: (progress: {
+        completed: number;
+        total: number;
+        percentage?: number;
+        currentTile?: string;
+        currentFont?: string;
+    }) => void;
+    [key: string]: unknown;
+};

package/dist/ui/ThemeManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Simplified theme system for dark/light mode management
+ * Now that all components use Tailwind CSS, we only need basic theme switching
+ */
+export type ThemeMode = 'light' | 'dark';
+export interface Theme {
+    mode: ThemeMode;
+}
+export declare const lightTheme: Theme;
+export declare const darkTheme: Theme;
+declare class ThemeManager {
+    private currentTheme;
+    private listeners;
+    constructor();
+    private initializeTheme;
+    getTheme(): Theme;
+    setTheme(mode: ThemeMode): void;
+    toggleTheme(): void;
+    subscribe(listener: (theme: Theme) => void): () => void;
+    private notifyListeners;
+}
+export declare const themeManager: ThemeManager;
+export {};

package/dist/ui/components/DownloadProgress.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Download progress section for the offline manager
+ */
+export interface DownloadProgress {
+    regionId: string;
+    completed: number;
+    total: number;
+    percentage: number;
+    currentResource: string;
+}
+export interface DownloadProgressSectionProps {
+    downloads: Map<string, DownloadProgress>;
+}
+export declare function createDownloadProgressSection(props: DownloadProgressSectionProps): HTMLDivElement;

package/dist/ui/components/PanelActions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Action buttons section for the offline manager
+ * Refactored to use modular components
+ */
+import { Theme } from '../ThemeManager';
+export interface ActionButtonsProps {
+    onAddRegion?: () => void;
+    onCleanup?: () => void;
+    onRefresh?: () => void;
+    theme?: Theme;
+}
+export declare function createActionButtons(props: ActionButtonsProps): HTMLDivElement;

package/dist/ui/components/PanelHeader.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Header component for the offline manager
+ * Refactored to use modular components
+ */
+import { Theme } from '../ThemeManager';
+export interface HeaderProps {
+    title: string;
+    subtitle: string;
+    onClose?: () => void;
+    onThemeToggle?: () => void;
+    onToggleTheme?: () => void;
+    showThemeToggle?: boolean;
+    theme?: Theme;
+}
+export declare function createHeader(props: HeaderProps): HTMLDivElement;