map-gl-offline 0.1.0-alpha.0

package/dist/ui/managers/PanelManager.d.ts

@@ -0,0 +1,160 @@
+/**
+ * Panel Renderer Component
+ * Handles rendering of the main offline manager panel
+ * Refactored to use modular components
+ */
+import { OfflineMapManager } from '../../managers/offlineMapManager';
+import { DownloadManager } from './downloadManager';
+import { ModalManager } from '../modals/modalManager';
+import { BaseComponent } from '../components/shared/BaseComponent';
+type MaplibreMap = unknown;
+export interface PanelRendererOptions {
+    offlineManager: OfflineMapManager;
+    downloadManager: DownloadManager;
+    modalManager: ModalManager;
+    onClose: () => void;
+    onAddRegion: () => void;
+    onFocusRegion: (regionId: string) => void;
+    showBbox?: boolean;
+    map?: MaplibreMap;
+}
+export declare class PanelRenderer extends BaseComponent {
+    private offlineManager;
+    private downloadManager;
+    private modalManager;
+    private options;
+    private map?;
+    private headerContainer?;
+    private actionButtonsContainer?;
+    private regionsList?;
+    private downloadProgressContainer?;
+    private refreshTimeout?;
+    private isRefreshing;
+    constructor(options: PanelRendererOptions);
+    protected createElement(): HTMLElement;
+    /**
+     * Render the main panel content
+     */
+    render(panelElement: HTMLDivElement): Promise<void>;
+    /**
+     * Render header section
+     */
+    private renderHeader;
+    /**
+     * Render action buttons section
+     */
+    private renderActionButtons;
+    /**
+     * Render download progress section
+     */
+    private renderDownloadProgress;
+    /**
+     * Render styles list with regions grouped under each style
+     */
+    private renderRegionsList;
+    /**
+     * Create region item template
+     */
+    private createRegionItemTemplate;
+    /**
+     * Create complete style template with header, HR, and regions
+     */
+    private createCompleteStyleTemplate;
+    /**
+     * Create region item specifically for embedding within a style container
+     */
+    private createRegionItemForStyle;
+    /**
+     * Create style item template with load button
+     */
+    private createStyleItemTemplate;
+    /**
+     * Create orphaned regions header template
+     */
+    private createOrphanedRegionsHeaderTemplate;
+    /**
+     * Create download progress HTML
+     */
+    private createDownloadProgressHTML;
+    /**
+     * Handle region actions
+     */
+    private handleRegionAction;
+    /**
+     * Handle showing region details
+     */
+    private handleShowRegionDetails;
+    /**
+     * Handle deleting a region
+     */
+    private handleDeleteRegion;
+    /**
+     * Handle re-downloading a region
+     */
+    private handleRedownloadRegion;
+    /**
+     * Handle import/export functionality
+     */
+    private handleImportExport;
+    /**
+     * Handle theme toggle
+     */
+    private handleThemeToggle;
+    /**
+     * Get theme icon based on current theme
+     */
+    private getThemeIcon;
+    /**
+     * Render error state
+     */
+    private renderErrorState;
+    /**
+     * Add event listeners for embedded region action buttons
+     */
+    private addRegionActionEventListeners;
+    /**
+     * Handle actions for embedded region buttons
+     */
+    private handleEmbeddedRegionAction;
+    /**
+     * Fallback renderer for regions list when styles fail to load
+     */
+    private renderFallbackRegionsList;
+    /**
+     * Refresh the panel content
+     */
+    refresh(): Promise<void>;
+    /**
+     * Perform the actual refresh
+     */
+    private performRefresh;
+    /**
+     * Cleanup when component is destroyed
+     */
+    destroy(): void;
+    /**
+     * Group regions by style ID
+     */
+    private groupRegionsByStyle;
+    /**
+     * Handle actions for both styles and regions
+     */
+    private handleItemAction;
+    /**
+     * Handle style-specific actions
+     */
+    private handleStyleAction;
+    /**
+     * Handle fixing compressed tiles
+     */
+    private handleFixCompressedTiles;
+    /**
+     * Handle loading a style to the map
+     */
+    private handleLoadStyle;
+    /**
+     * Handle deleting a style
+     */
+    private handleDeleteStyle;
+}
+export {};

package/dist/ui/managers/downloadManager.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Download Manager Component
+ * Handles download operations and progress tracking
+ */
+import { OfflineMapManager } from '../../managers/offlineMapManager';
+import { RegionFormData } from '../modals/regionFormModal';
+export interface DownloadProgress {
+    regionId: string;
+    completed: number;
+    total: number;
+    percentage: number;
+    currentResource: string;
+}
+export interface DownloadManagerOptions {
+    offlineManager: OfflineMapManager;
+    onProgressUpdate?: (downloads: Map<string, DownloadProgress>) => void;
+    onDownloadComplete?: (regionId: string) => void;
+    onDownloadError?: (regionId: string, error: Error | string) => void;
+    updateButton?: (text: string, disabled: boolean) => void;
+    updateProgressBadge?: (text: string, visible: boolean) => void;
+}
+export declare class DownloadManager {
+    private offlineManager;
+    private currentDownloads;
+    private options;
+    constructor(options: DownloadManagerOptions);
+    /**
+     * Start downloading a region with progress tracking
+     */
+    downloadRegion(formData: RegionFormData): Promise<void>;
+    /**
+     * Get current downloads
+     */
+    getCurrentDownloads(): Map<string, DownloadProgress>;
+    /**
+     * Check if any downloads are in progress
+     */
+    hasActiveDownloads(): boolean;
+    /**
+     * Cancel a specific download
+     */
+    cancelDownload(regionId: string): void;
+    /**
+     * Cancel all downloads
+     */
+    cancelAllDownloads(): void;
+    /**
+     * Update UI for download start
+     */
+    private updateUIForDownloadStart;
+    /**
+     * Handle successful download completion
+     */
+    private handleDownloadComplete;
+    /**
+     * Handle download error
+     */
+    private handleDownloadError;
+    /**
+     * Reset UI to initial state
+     */
+    private resetUI;
+}

package/dist/ui/modals/confirmationModal.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Confirmation Modal Component
+ * Handles confirmation dialogs with customizable actions
+ * Refactored to use modular components
+ */
+export interface ConfirmationModalOptions {
+    title: string;
+    message: string;
+    confirmText: string;
+    cancelText: string;
+    onConfirm: () => void;
+    onCancel: () => void;
+}
+export declare class ConfirmationModal {
+    private options;
+    private modal?;
+    constructor(options: ConfirmationModalOptions);
+    /**
+     * Show confirmation modal and return modal element
+     */
+    show(): HTMLDivElement;
+    /**
+     * Hide the modal
+     */
+    hide(): void;
+    /**
+     * Destroy the modal
+     */
+    destroy(): void;
+}

package/dist/ui/modals/importExportModal.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Import/Export Modal Component
+ * Handles import/export operations for regions
+ * Refactored to use modular Modal component for consistency
+ */
+import type { StoredRegion, ImportExportOptions, ExportResult, ImportResult, RegionImportData } from '../../types';
+export interface ImportExportModalOptions {
+    region: StoredRegion;
+    onClose: () => void;
+    onExport?: (result: ExportResult) => void;
+    onImport?: (result: ImportResult) => void;
+    exportRegion?: (regionId: string, format: 'json' | 'pmtiles' | 'mbtiles', options?: ImportExportOptions) => Promise<ExportResult>;
+    importRegion?: (data: RegionImportData) => Promise<ImportResult>;
+}
+export declare class ImportExportModal {
+    private modal?;
+    private options;
+    private isExporting;
+    private isImporting;
+    private exportFormatSelect?;
+    private includeStyleCheckbox?;
+    private includeTilesCheckbox?;
+    private includeSpritesCheckbox?;
+    private includeFontsCheckbox?;
+    private exportProgressBar?;
+    private exportProgressText?;
+    private exportButton?;
+    private importFileInput?;
+    private importNameInput?;
+    private importOverwriteCheckbox?;
+    private importProgressBar?;
+    private importProgressText?;
+    private importButton?;
+    constructor(options: ImportExportModalOptions);
+    show(): HTMLDivElement;
+    hide(): void;
+    private createContent;
+    private createRegionInfoCard;
+    private createExportSection;
+    private createImportSection;
+    private createFormatGuide;
+    private attachEventListeners;
+    private handleExport;
+    private handleImport;
+    destroy(): void;
+}

package/dist/ui/modals/importExportModal.old.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Import/Export Modal Component
+ * Handles import/export operations for regions
+ */
+import type { StoredRegion, ImportExportOptions, ExportResult, ImportResult, RegionImportData } from '../../types';
+export interface ImportExportModalOptions {
+    region: StoredRegion;
+    onClose: () => void;
+    onExport?: (result: ExportResult) => void;
+    onImport?: (result: ImportResult) => void;
+    exportRegion?: (regionId: string, format: 'json' | 'pmtiles' | 'mbtiles', options?: ImportExportOptions) => Promise<ExportResult>;
+    importRegion?: (data: RegionImportData) => Promise<ImportResult>;
+}
+export declare class ImportExportModal {
+    private modal;
+    private options;
+    private isExporting;
+    private isImporting;
+    constructor(options: ImportExportModalOptions);
+    show(): HTMLDivElement;
+    hide(): void;
+    private createModal;
+    private attachEventListeners;
+    private updateExportOptions;
+    private handleExport;
+    private handleImport;
+}

package/dist/ui/modals/modalManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Modal Manager Component
+ * Centralized management of modal dialogs
+ */
+export declare class ModalManager {
+    private activeModal;
+    /**
+     * Show a modal
+     */
+    show(modal: HTMLDivElement): void;
+    /**
+     * Close the current modal
+     */
+    close(): void;
+    /**
+     * Check if a modal is currently open
+     */
+    isOpen(): boolean;
+    /**
+     * Get the current active modal
+     */
+    getActiveModal(): HTMLDivElement | undefined;
+}

package/dist/ui/modals/regionDetailsModal.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Region Details Modal Component
+ * Shows detailed information about a specific region
+ * Refactored to use modular components
+ */
+import { StoredRegion } from '../../types/region';
+export interface RegionDetailsOptions {
+    region: StoredRegion;
+    onClose: () => void;
+    onFocus: (regionId: string) => void;
+    onThemeToggle?: () => void;
+}
+export declare class RegionDetailsModal {
+    private options;
+    private modal?;
+    constructor(options: RegionDetailsOptions);
+    /**
+     * Show the region details modal
+     */
+    show(): HTMLDivElement;
+    /**
+     * Create the modal content
+     */
+    private createContent;
+    /**
+     * Create the footer with action buttons
+     */
+    private createFooter;
+    /**
+     * Focus on the region in the map
+     */
+    focusRegion(): void;
+    /**
+     * Close the modal
+     */
+    close(): void;
+}

package/dist/ui/modals/regionFormModal.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Region Form Modal Component
+ * Handles the form for creating new offline regions
+ * Refactored to use modular components
+ */
+export interface RegionFormData {
+    name: string;
+    minZoom: number;
+    maxZoom: number;
+    styleUrl: string;
+    bounds: [number, number, number, number];
+    provider?: 'mapbox' | 'maplibre' | 'auto';
+    accessToken?: string;
+}
+export interface RegionFormOptions {
+    bounds: [number, number, number, number];
+    area: number;
+    onSave: (formData: RegionFormData) => Promise<void>;
+    onCancel: () => void;
+    onThemeToggle?: () => void;
+    styleUrl: string;
+}
+export declare class RegionFormModal {
+    private options;
+    private modal?;
+    private nameInput?;
+    private minZoomInput?;
+    private maxZoomInput?;
+    private styleUrlInput?;
+    private providerSelect?;
+    private accessTokenInput?;
+    private accessTokenGroup?;
+    constructor(options: RegionFormOptions);
+    /**
+     * Show the region form modal
+     */
+    show(): HTMLDivElement;
+    /**
+     * Create the form content
+     */
+    private createForm;
+    /**
+     * Handle style URL changes to auto-detect provider
+     */
+    private handleStyleUrlChange;
+    /**
+     * Handle provider selection changes
+     */
+    private handleProviderChange;
+    /**
+     * Auto-detect provider from style URL
+     */
+    private detectProviderFromUrl;
+    /**
+     * Toggle access token input visibility
+     */
+    private toggleAccessTokenVisibility;
+    /**
+     * Create the footer with action buttons
+     */
+    private createFooter;
+    /**
+     * Handle form save
+     */
+    private handleSave;
+    /**
+     * Hide the modal
+     */
+    hide(): void;
+    /**
+     * Destroy the modal
+     */
+    destroy(): void;
+    /**
+     * Handle form cancel - kept for backward compatibility
+     */
+    cancel(): void;
+    /**
+     * Handle form save - kept for backward compatibility
+     */
+    save(): Promise<void>;
+    /**
+     * Close the modal - kept for backward compatibility
+     */
+    close(): void;
+}

package/dist/ui/offlineManagerControl.d.ts

@@ -0,0 +1,120 @@
+import type { IControl, Map as MaplibreMap } from 'maplibre-gl';
+import { OfflineMapManager } from '../managers/offlineMapManager';
+export interface OfflineManagerControlOptions {
+    styleUrl: string;
+    theme?: 'light' | 'dark';
+    showBbox?: boolean;
+}
+export declare class OfflineManagerControl implements IControl {
+    private map;
+    private panel;
+    private isOpen;
+    private offlineManager;
+    private options;
+    private buttonManager;
+    private panelRenderer;
+    private regionControl;
+    private downloadManager;
+    private modalManager;
+    private bboxLayerAdded;
+    private originalFetch;
+    constructor(offlineManager: OfflineMapManager, options?: OfflineManagerControlOptions);
+    /**
+     * Setup fetch interceptor to handle idb:// URLs
+     */
+    private setupFetchInterceptor;
+    onAdd(map: MaplibreMap): HTMLElement;
+    onRemove(): void;
+    /**
+     * Create panel element
+     */
+    private createPanel;
+    /**
+     * Toggle panel visibility
+     */
+    private togglePanel;
+    /**
+     * Close panel
+     */
+    private closePanel;
+    /**
+     * Render panel content
+     */
+    private renderPanel;
+    /**
+     * Start region selection mode
+     */
+    private startRegionSelection;
+    /**
+     * Handle region saved event
+     */
+    private handleRegionSaved;
+    /**
+     * Handle progress updates from download manager
+     */
+    private handleProgressUpdate;
+    /**
+     * Handle download completion
+     */
+    private handleDownloadComplete;
+    /**
+     * Handle download error
+     */
+    private handleDownloadError;
+    /**
+     * Update button state
+     */
+    private updateButton;
+    /**
+     * Update progress badge
+     */
+    private updateProgressBadge;
+    /**
+     * Handle panel click events
+     */
+    private handlePanelClick;
+    /**
+     * Focus on a specific region on the map
+     */
+    private focusRegion;
+    /**
+     * Show bounding box for a region on the map
+     */
+    private showRegionBoundingBox;
+    /**
+     * Initialize bounding box layer on the map
+     */
+    private initializeBboxLayer;
+    /**
+     * Remove bounding box from the map
+     */
+    private removeRegionBoundingBox;
+    /**
+     * Load offline style for a specific style ID
+     */
+    loadOfflineStyle(styleId: string): Promise<void>;
+    /**
+     * Load styles from IndexedDB and apply to map
+     */
+    private loadStylesFromIDB;
+    /**
+     * Show modal to select which style to load
+     */
+    private showStyleSelectionModal;
+    /**
+     * Public method to load offline styles - can be called from outside
+     */
+    loadOfflineStyles(): Promise<void>;
+    /**
+     * Public method to load a specific offline style by ID
+     */
+    loadSpecificOfflineStyle(styleId: string): Promise<void>;
+    /**
+     * Update the current style URL for the offline manager
+     */
+    updateStyleUrl(newStyleUrl: string): void;
+    /**
+     * Get the current style URL
+     */
+    getCurrentStyleUrl(): string;
+}

package/dist/utils/asyncUtils.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Delays execution for specified milliseconds
+ */
+export declare function delay(ms: number): Promise<void>;
+/**
+ * Retry a function with exponential backoff
+ */
+export declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries?: number, baseDelay?: number): Promise<T>;
+/**
+ * Throttle function calls
+ */
+export declare function throttle<T extends (...args: unknown[]) => unknown>(func: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Debounce function calls
+ */
+export declare function debounce<T extends (...args: unknown[]) => unknown>(func: T, delay: number): (...args: Parameters<T>) => void;
+/**
+ * Create a promise that resolves after a timeout
+ */
+export declare function timeout<T>(promise: Promise<T>, ms: number): Promise<T>;
+/**
+ * Batch process items with concurrency control
+ */
+export declare function batchProcess<T, R>(items: T[], processor: (item: T) => Promise<R>, batchSize?: number): Promise<R[]>;

package/dist/utils/cleanupCompressedTiles.d.ts

@@ -0,0 +1,12 @@
+export interface CompressedTileStats {
+    total: number;
+    gzipped: number;
+    uncompressed: number;
+}
+export interface CompressedTileCleanupResult {
+    checked: number;
+    removed: number;
+    errors: string[];
+}
+export declare function countCompressedTiles(): Promise<CompressedTileStats>;
+export declare function cleanupCompressedTiles(): Promise<CompressedTileCleanupResult>;