map-gl-offline 0.1.0-alpha.0

package/dist/services/styleService.d.ts

@@ -0,0 +1,73 @@
+import type { StyleProvider, StyleDownloadOptions, StyleDownloadResult, StyleStorageItem, EnhancedStyleStats } from '../types';
+export declare function downloadStyles(stylesUrl: string, options?: StyleDownloadOptions): Promise<StyleDownloadResult>;
+export declare function loadStyles(): Promise<StyleStorageItem[]>;
+export declare function loadStyleById(styleId: string): Promise<StyleStorageItem | null>;
+export declare function deleteStyles(): Promise<void>;
+export declare function deleteStyleById(styleId: string): Promise<void>;
+/**
+ * Get enhanced style statistics
+ */
+export declare function getStyleStats(): Promise<EnhancedStyleStats>;
+/**
+ * Clean up old styles based on criteria
+ */
+export declare function cleanupOldStyles(options?: {
+    maxAge?: number;
+    maxCount?: number;
+    maxSize?: number;
+    keepIds?: string[];
+    onProgress?: (progress: {
+        completed: number;
+        total: number;
+        message: string;
+    }) => void;
+}): Promise<{
+    deletedCount: number;
+    freedSpace: number;
+    errors: string[];
+}>;
+export declare function isStyleDownloaded(styleId?: string, styleUrl?: string): Promise<boolean>;
+/**
+ * Verify and validate style integrity
+ */
+export declare function verifyAndValidateStyles(options?: {
+    onProgress?: (progress: {
+        completed: number;
+        total: number;
+        message: string;
+    }) => void;
+    autoRepair?: boolean;
+}): Promise<{
+    totalStyles: number;
+    validStyles: number;
+    invalidStyles: number;
+    repairedStyles: number;
+    errors: Array<{
+        id: string;
+        error: string;
+    }>;
+}>;
+/**
+ * Get comprehensive style analytics
+ */
+export declare function getStyleAnalytics(): Promise<{
+    totalStyles: number;
+    totalSize: number;
+    totalSources: number;
+    totalLayers: number;
+    sourceTypeBreakdown: Record<string, number>;
+    layerTypeBreakdown: Record<string, number>;
+    stylesWithGlyphs: number;
+    stylesWithSprites: number;
+    averageLayersPerStyle: number;
+    averageSourcesPerStyle: number;
+    recommendations: string[];
+}>;
+/**
+ * Enhanced style download that supports both Mapbox GL and MapLibre GL
+ */
+export declare function downloadStyleWithProvider(styleUrl: string, options?: StyleDownloadOptions & {
+    provider?: StyleProvider;
+    accessToken?: string;
+    forceProvider?: boolean;
+}): Promise<StyleDownloadResult>;

package/dist/services/tileService.d.ts

@@ -0,0 +1,24 @@
+import type { TileDownloadOptions, TileDownloadResult, TileStats, OfflineRegionOptions, MapboxStyle } from '../types';
+export declare class TileService {
+    private db;
+    downloadTiles(region: OfflineRegionOptions, style: MapboxStyle, styleId: string, options?: TileDownloadOptions): Promise<TileDownloadResult>;
+    getTileStats(styleId?: string): Promise<TileStats>;
+    cleanupOldTiles(maxAge?: number, styleId?: string): Promise<number>;
+    getTileAnalytics(styleId?: string): Promise<Record<string, unknown>>;
+    private generateTileCoordinates;
+    private extractTileSources;
+    private createTileKey;
+    private getExistingTileKeys;
+    private compressTile;
+    private rateLimitDelay;
+    private extractExtension;
+    private selectTileTemplate;
+    private populateTemplate;
+    private resolveTileContentType;
+    private parseTileKey;
+}
+export declare const tileService: TileService;
+export declare const downloadTiles: (region: OfflineRegionOptions, style: MapboxStyle, styleId: string, options?: TileDownloadOptions) => Promise<TileDownloadResult>;
+export declare const getTileStats: (styleId?: string) => Promise<TileStats>;
+export declare const getTileAnalytics: (styleId?: string) => Promise<Record<string, unknown>>;
+export declare const cleanupOldTiles: (maxAge?: number, styleId?: string) => Promise<number>;

package/dist/storage/indexedDbManager.d.ts

@@ -0,0 +1,2 @@
+import { OfflineMapDB } from '../types';
+export declare const dbPromise: Promise<import("idb").IDBPDatabase<OfflineMapDB>>;

package/dist/style.css

@@ -0,0 +1,213 @@
+@import "tailwindcss";
+
+/* CSS custom properties for theming */
+:root {
+  --color-primary: #8B5CF6;
+  --color-primary-hover: #7C3AED;
+  --color-success: #10B981;
+  --color-success-hover: #059669;
+  --color-warning: #F59E0B;
+  --color-error: #EF4444;
+  --color-surface: #F8FAFC;
+  --color-text: #1E293B;
+  --color-border: #E2E8F0;
+}
+
+/* Custom component styles using regular CSS */
+@layer components {
+  .offline-manager-control {
+    font-family: system-ui, sans-serif;
+  }
+  
+  /* Button Components */
+  .btn-primary {
+    background-color: var(--color-primary);
+    color: white;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-primary:hover {
+    background-color: var(--color-primary-hover);
+  }
+  
+  .btn-secondary {
+    background-color: #F9FAFB;
+    color: #374151;
+    border: 1px solid #D1D5DB;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-secondary:hover {
+    background-color: #F3F4F6;
+  }
+  
+  .btn-success {
+    background-color: var(--color-success);
+    color: white;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-success:hover {
+    background-color: var(--color-success-hover);
+  }
+  
+  .btn-error {
+    background-color: var(--color-error);
+    color: white;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-error:hover {
+    background-color: #DC2626;
+  }
+  
+  .btn-warning {
+    background-color: var(--color-warning);
+    color: white;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    border: none;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-warning:hover {
+    background-color: #D97706;
+  }
+  
+  .btn-ghost {
+    background-color: transparent;
+    color: #374151;
+    border: none;
+    padding: 8px 16px;
+    border-radius: 6px;
+    transition: all 0.2s;
+    cursor: pointer;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 8px;
+    text-align: center;
+    white-space: nowrap;
+    user-select: none;
+    outline: none;
+    box-sizing: border-box;
+    font-size: 14px;
+    font-weight: 500;
+    min-height: 40px;
+  }
+  
+  .btn-ghost:hover {
+    background-color: #F3F4F6;
+  }
+  
+  /* Button sizes */
+  .btn-sm {
+    font-size: 12px;
+    padding: 6px 12px;
+    min-height: 32px;
+  }
+  
+  .btn-md {
+    font-size: 14px;
+    padding: 8px 16px;
+    min-height: 40px;
+  }
+  
+  .btn-lg {
+    font-size: 16px;
+    padding: 12px 24px;
+    min-height: 48px;
+  }
+
+  /* Enhanced form styles for Mapbox GL support */
+  .provider-info {
+    font-size: 12px;
+    color: #6B7280;
+    margin-top: 4px;
+  }
+
+  .access-token-info {
+    background-color: #FEF3C7;
+    border: 1px solid #F59E0B;
+    padding: 8px;
+    margin-top: 8px;
+    font-size: 12px;
+    color: #92400E;
+  }
+}

package/dist/types/cleanup.d.ts

@@ -0,0 +1,49 @@
+export interface RegionCleanupOptions {
+    maxAge?: number;
+    maxStorageSize?: number;
+    maxRegions?: number;
+    priorityPatterns?: string[];
+    onProgress?: (progress: {
+        phase: 'scanning' | 'analyzing' | 'cleaning';
+        completed: number;
+        total: number;
+        message: string;
+    }) => void;
+}
+export interface CleanupResult {
+    scannedRegions: number;
+    expiredRegions: number;
+    deletedRegions: number;
+    preservedRegions: number;
+    freedSpace: number;
+    errors: string[];
+    recommendations: string[];
+}
+export interface RegionAnalytics {
+    totalRegions: number;
+    totalSize: number;
+    averageSize: number;
+    oldestRegion?: {
+        id: string;
+        created: number;
+    };
+    newestRegion?: {
+        id: string;
+        created: number;
+    };
+    largestRegion?: {
+        id: string;
+        size: number;
+    };
+    smallestRegion?: {
+        id: string;
+        size: number;
+    };
+    regionsByStyle: Record<string, number>;
+    expiryDistribution: {
+        expired: number;
+        expiringWithin24h: number;
+        expiringWithin7d: number;
+        neverExpiring: number;
+    };
+}

package/dist/types/database.d.ts

@@ -0,0 +1,33 @@
+import { DBSchema } from 'idb';
+import type { StoredRegion } from './region';
+import type { StyleEntry } from './style';
+import type { FontEntry } from './font';
+import type { TileEntry } from './tile';
+import type { SpriteEntry } from './sprite';
+import type { GlyphEntry } from './glyph';
+export interface OfflineMapDB extends DBSchema {
+    regions: {
+        key: string;
+        value: StoredRegion;
+    };
+    tiles: {
+        key: string;
+        value: TileEntry;
+    };
+    sprites: {
+        key: string;
+        value: SpriteEntry;
+    };
+    glyphs: {
+        key: string;
+        value: GlyphEntry;
+    };
+    styles: {
+        key: string;
+        value: StyleEntry;
+    };
+    fonts: {
+        key: string;
+        value: FontEntry;
+    };
+}

package/dist/types/font.d.ts

@@ -0,0 +1,115 @@
+import { DownloadProgress } from './progress';
+/**
+ * Font entry stored in IndexedDB
+ */
+export interface FontEntry {
+    /** Unique identifier for the font (e.g., "Roboto/0-255") */
+    key: string;
+    /** Raw font data in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** ISO 8601 timestamp when font was downloaded */
+    downloadedAt: string;
+    /** Font file size in bytes */
+    size: number;
+    /** Font file type (e.g., "pbf", "ttf", "woff2") */
+    type: string;
+    /** Final URL used for download (may differ from originalUrl due to redirects) */
+    url: string;
+    /** Original URL before any transformations */
+    originalUrl: string;
+    /** Last-Modified timestamp from HTTP headers (milliseconds since epoch) */
+    lastModified: number;
+    /** MIME type from HTTP Content-Type header */
+    contentType: string;
+    /** Optional identifier linking this font to a specific download batch */
+    downloadId?: string;
+    /** Additional metadata about the download */
+    metadata?: {
+        /** User agent string used for download */
+        userAgent?: string;
+        /** Timestamp when download was initiated */
+        downloadTimestamp?: number;
+    };
+}
+/**
+ * Configuration options for font downloads
+ */
+export interface FontDownloadOptions {
+    /** Callback for progress updates */
+    onProgress?: (progress: DownloadProgress) => void;
+    /** Number of fonts to download concurrently (default: 10) */
+    batchSize?: number;
+    /** Maximum retry attempts for failed downloads (default: 3) */
+    maxRetries?: number;
+    /** CORS proxy URL for cross-origin requests */
+    corsProxy?: string;
+    /** Skip fonts that already exist in storage (default: true) */
+    skipExisting?: boolean;
+    /** Delay in milliseconds between retry attempts (default: 1000) */
+    retryDelay?: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Validate font data after download (default: true) */
+    validateFonts?: boolean;
+    /** Maximum number of concurrent downloads (default: 5) */
+    maxConcurrency?: number;
+    /** Check storage quota before starting download (default: true) */
+    storageQuotaCheck?: boolean;
+    /** Continue downloading even if some fonts fail (default: false) */
+    continueOnError?: boolean;
+    /** Reduce console logging for failed fonts (default: false) */
+    quietMode?: boolean;
+}
+/**
+ * Result of a font download operation
+ */
+export interface FontDownloadResult {
+    /** Total number of fonts in download plan */
+    totalFonts: number;
+    /** Number of fonts successfully downloaded */
+    downloadedFonts: number;
+    /** Number of fonts skipped (already existed) */
+    skippedFonts: number;
+    /** Number of fonts that failed to download */
+    failedFonts: number;
+    /** Total size of all downloaded fonts in bytes */
+    totalSize: number;
+    /** Total download time in milliseconds */
+    downloadTime: number;
+    /** Average download speed in bytes per second */
+    averageSpeed: number;
+    /** Array of error details for failed downloads */
+    errors: Array<{
+        url: string;
+        error: string;
+    }>;
+    /** Distribution of fonts by file type (e.g., {"pbf": 45, "ttf": 10}) */
+    fontsByType: Record<string, number>;
+}
+/**
+ * Enhanced statistics about stored fonts
+ */
+export interface EnhancedFontStats {
+    /** Total number of stored fonts */
+    count: number;
+    /** Total storage size in bytes */
+    totalSize: number;
+    /** Average font size in bytes */
+    averageSize: number;
+    /** Array of font keys */
+    fonts: string[];
+    /** Distribution by file type */
+    fontsByType: Record<string, number>;
+    /** Oldest font in storage */
+    oldestFont?: {
+        key: string;
+        timestamp: number;
+    };
+    /** Newest font in storage */
+    newestFont?: {
+        key: string;
+        timestamp: number;
+    };
+    /** Array of font keys that failed validation */
+    corruptedFonts: string[];
+}

package/dist/types/glyph.d.ts

@@ -0,0 +1,127 @@
+/**
+ * Glyph entry stored in IndexedDB
+ */
+export interface GlyphEntry {
+    /** Unique identifier for the glyph (e.g., "Roboto-Regular/0-255") */
+    key: string;
+    /** Raw glyph data (PBF format) in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** Last-Modified timestamp from HTTP headers (milliseconds since epoch) */
+    lastModified: number;
+    /** ISO 8601 timestamp when glyph was downloaded */
+    downloadedAt: string;
+    /** Glyph file size in bytes */
+    size: number;
+    /** Final URL used for download */
+    url: string;
+    /** Optional identifier linking glyph to a style */
+    styleId?: string;
+    /** Font stack name (e.g., "Roboto-Regular", "Arial Unicode MS Bold") */
+    fontstack?: string;
+    /** Unicode range (e.g., "0-255", "256-511") */
+    range?: string;
+}
+/**
+ * Glyph range data
+ */
+export interface GlyphRange {
+    /** Starting Unicode code point */
+    start: number;
+    /** Ending Unicode code point */
+    end: number;
+    /** Raw glyph data in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** MIME type (typically "application/x-protobuf") */
+    contentType?: string;
+}
+/**
+ * Local glyph entry with extended metadata
+ */
+export interface LocalGlyphEntry {
+    /** Unique identifier (format: "fontstack/range") */
+    key: string;
+    /** Font stack name */
+    fontstack: string;
+    /** Unicode range string */
+    range: string;
+    /** Raw glyph data in ArrayBuffer format */
+    data: ArrayBuffer;
+    /** MIME type */
+    contentType: string;
+    /** Glyph file size in bytes */
+    size: number;
+    /** Last modification timestamp (milliseconds since epoch) */
+    lastModified: number;
+    /** Extended metadata */
+    metadata?: {
+        /** Unicode range description (e.g., "Basic Latin") */
+        unicodeRange: string;
+        /** Number of glyphs in this range */
+        glyphCount: number;
+        /** Compression ratio if compressed */
+        compressionRatio?: number;
+    };
+}
+/**
+ * Configuration options for glyph downloads
+ */
+export interface GlyphDownloadOptions {
+    /** Maximum number of concurrent downloads (default: 5) */
+    maxConcurrency?: number;
+    /** Maximum retry attempts for failed downloads (default: 3) */
+    retries?: number;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Callback for progress updates */
+    onProgress?: (progress: {
+        completed: number;
+        total: number;
+        currentFont: string;
+    }) => void;
+    /** Include additional metadata in stored glyphs (default: false) */
+    includeMetadata?: boolean;
+    /** Validate glyph data after download (default: true) */
+    enableValidation?: boolean;
+    /** Array of font stacks to prioritize */
+    priorityFonts?: string[];
+}
+/**
+ * Result of a glyph download operation
+ */
+export interface GlyphDownloadResult {
+    /** Total number of glyphs in download plan */
+    totalGlyphs: number;
+    /** Number of glyphs successfully downloaded */
+    downloadedGlyphs: number;
+    /** Number of glyphs skipped (already existed) */
+    skippedGlyphs: number;
+    /** Number of glyphs that failed to download */
+    failedGlyphs: number;
+    /** Total size of all downloaded glyphs in bytes */
+    totalSize: number;
+    /** Average download speed in bytes per second */
+    downloadSpeed: number;
+    /** Total download time in milliseconds */
+    duration: number;
+    /** Array of error messages for failed downloads */
+    errors: string[];
+    /** Detailed analytics about downloaded glyphs */
+    analytics: {
+        /** Distribution by font stack */
+        fontsByStack: Record<string, number>;
+        /** Average glyph size in bytes */
+        averageGlyphSize: number;
+        /** Largest glyph details */
+        largestGlyph: {
+            fontstack: string;
+            range: string;
+            size: number;
+        };
+        /** Smallest glyph details */
+        smallestGlyph: {
+            fontstack: string;
+            range: string;
+            size: number;
+        };
+    };
+}