aviation-chart 0.1.35 → 0.2.0

package/dist/managers/ADSBManager.d.ts

@@ -0,0 +1,39 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+export declare class ADSB {
+    private map;
+    private readonly sourceId;
+    private readonly pointLayerId;
+    private readonly labelLayerId;
+    private opened;
+    private enableInterpolation;
+    private interpolationTimer;
+    private lastUpdateTime;
+    private currentFeatures;
+    private interpolatedFeatures;
+    private minZoomForInterpolation;
+    private lastBounds;
+    private boundsChangeThreshold;
+    private lastTimeStamps;
+    constructor(map: MaplibreMap);
+    open(pointLayerConfig?: any, labelLayerConfig?: any, enableInterpolation?: boolean): void;
+    close(): void;
+    update(features: any): void;
+    private startInterpolation;
+    private stopInterpolation;
+    private performInterpolation;
+    private interpolateFeature;
+    private mergeFeaturesWithInterpolation;
+    private getFeatureId;
+    private hasTimeStampChanged;
+    private compareTimeStamps;
+    private hasPositionChanged;
+    private getTimeStamp;
+    private updateTimeStampCache;
+    private hasSignificantPositionChange;
+    private getVisibleFeatures;
+    private isFeatureInBounds;
+    private hasBoundsChanged;
+    private updateMapDisplay;
+    destroy(): void;
+    private mergeLayerConfig;
+}

package/dist/managers/ClickManager.d.ts

@@ -0,0 +1,15 @@
+import type { LayerRef, HtmlFunction } from "../types";
+import type { Map as MaplibreMap, PopupOptions } from "maplibre-gl";
+type OffHandler = () => void;
+type LayerCallback = (e: any) => void;
+export declare class ClickManager {
+    private map;
+    private cleanupFunctions;
+    constructor(map: MaplibreMap);
+    private resolveArray;
+    private arrayifyAndOff;
+    clickLayer: (layers: LayerRef, cb: LayerCallback) => OffHandler;
+    clickPopup(layers: LayerRef, htmlFunc: HtmlFunction, popupOptions?: PopupOptions): OffHandler;
+    private clearLayerListeners;
+}
+export {};

package/dist/managers/ErrorManager.d.ts

@@ -0,0 +1,25 @@
+import type { SDKError, ErrorHandler, HookCallback } from '../types';
+export declare class ErrorManager {
+    private errorHandlers;
+    private errorHistory;
+    private maxErrorHistory;
+    private hooks;
+    constructor();
+    createError(message: string, code: string, details?: any, recoverable?: boolean): SDKError;
+    addErrorHandler(handler: ErrorHandler): void;
+    removeErrorHandler(handler: ErrorHandler): void;
+    handleError(error: SDKError): Promise<void>;
+    private recordError;
+    getErrorHistory(): SDKError[];
+    clearErrorHistory(): void;
+    getErrorStats(): {
+        total: number;
+        recoverable: number;
+        nonRecoverable: number;
+    };
+    addHook(hookName: string, callback: HookCallback): void;
+    removeHook(hookName: string, callback: HookCallback): void;
+    triggerHook(hookName: string, context: any): Promise<void>;
+    private setupGlobalErrorHandling;
+    destroy(): void;
+}

package/dist/managers/GeoJSONManager.d.ts

@@ -0,0 +1,29 @@
+import type { Map as MaplibreMap, GeoJSONSourceSpecification } from "maplibre-gl";
+import type { GeoJSONFeature, StyleConfig, IGeoJSONManager, ClusteringConfig } from "../types";
+import { PerformanceManager } from "./PerformanceManager";
+import type { GeoJSON } from "geojson";
+export declare class GeoJSONManager implements IGeoJSONManager {
+    private map;
+    private features;
+    private featureCounter;
+    private performanceManager;
+    constructor(map: MaplibreMap, performanceManager?: PerformanceManager);
+    private generateFeatureId;
+    addPoint(coordinates: [number, number], properties?: Record<string, any>, style?: StyleConfig, id?: string): string;
+    addLine(coordinates: [number, number][], properties?: Record<string, any>, style?: StyleConfig, id?: string): string;
+    addPolygon(coordinates: [number, number][][], properties?: Record<string, any>, style?: StyleConfig, id?: string): string;
+    addGeoJSON(sourceId: string, geojson?: GeoJSON | string | null | undefined, props?: GeoJSONSourceSpecification | null | undefined): any;
+    private addFeature;
+    removeFeature(id: string): boolean;
+    updateFeature(id: string, updates: Partial<GeoJSONFeature>): boolean;
+    clearAllFeatures(): void;
+    getFeature(id: string): GeoJSONFeature | undefined;
+    getAllFeatures(): GeoJSONFeature[];
+    setClusteringEnabled(enabled: boolean): void;
+    setClusteringConfig(layerId: string, config: ClusteringConfig): void;
+    private createFeatureLayer;
+    private removeFeatureLayer;
+    private getLayerType;
+    private getDefaultPaint;
+    private getDefaultLayout;
+}

package/dist/managers/GlobalConfigManager.d.ts

@@ -0,0 +1,48 @@
+export interface GlobalConfig {
+    apiKey?: string;
+    baseUrl?: string;
+    version?: string;
+    period?: string;
+    chartConfig?: {
+        enableAIP?: boolean;
+        enableNOTAM?: boolean;
+        enableADSB?: boolean;
+        defaultCenter?: [number, number];
+        defaultZoom?: number;
+    };
+    styleConfig?: {
+        theme?: "light" | "dark";
+        language?: "zh-CN" | "en-US";
+    };
+    periodConfig?: {
+        switchDay?: number;
+    };
+    [key: string]: any;
+}
+declare class GlobalConfigManager {
+    private static instance;
+    private config;
+    private listeners;
+    private mapReinitCallback;
+    private constructor();
+    static getInstance(): GlobalConfigManager;
+    private parseURLParams;
+    private parseBooleanParam;
+    private getCurrentScriptUrl;
+    refreshFromURL(): void;
+    setConfig(newConfig: Partial<GlobalConfig>): void;
+    getConfig(): GlobalConfig;
+    getConfigItem<T>(key: string, defaultValue?: T): T | undefined;
+    updateConfigItem<T>(key: string, value: T): void;
+    addListener(event: string, callback: Function): () => void;
+    removeListener(event: string, callback: Function): void;
+    private notifyListeners;
+    reset(): void;
+    setPeriod(period: string): void;
+    getPeriod(): string | undefined;
+    generateCurrentPeriod(): Promise<string>;
+    setMapReinitCallback(callback: (() => void | Promise<void>) | null): void;
+    destroy(): void;
+}
+export declare const globalConfig: GlobalConfigManager;
+export type { GlobalConfigManager };

package/dist/managers/Graticule.d.ts

@@ -0,0 +1,41 @@
+import { Map as MaplibreMap } from 'maplibre-gl';
+export interface GraticuleConfig {
+    enabled?: boolean;
+    interval?: number;
+    lineColor?: string;
+    lineWidth?: number;
+    lineOpacity?: number;
+    lineDasharray?: number[];
+    labelColor?: string;
+    labelSize?: number;
+    showLabels?: boolean;
+    labelFormat?: 'decimal' | 'dms';
+}
+export declare class GraticuleManager {
+    private map;
+    private config;
+    private isVisible;
+    private sourceId;
+    private pointSourceId;
+    private lineLayerId;
+    private lonLabelLayerId;
+    private latLabelLayerId;
+    private lastInterval;
+    constructor(map: MaplibreMap, config?: GraticuleConfig);
+    private initialize;
+    private addGraticuleSources;
+    private addGraticuleLayers;
+    private getDynamicInterval;
+    private generateGraticuleData;
+    private formatCoordinate;
+    update(): void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    updateConfig(newConfig: Partial<GraticuleConfig>): void;
+    private refresh;
+    remove(): void;
+    getConfig(): Required<GraticuleConfig>;
+    isGraticuleVisible(): boolean;
+    destroy(): void;
+}

package/dist/managers/HoverManage.d.ts

@@ -0,0 +1,26 @@
+import type { LayerRef, HtmlFunction } from "../types";
+import type { Map as MaplibreMap, PopupOptions } from "maplibre-gl";
+export interface HoverConfig {
+    layerId: string;
+    hoverColor?: string;
+    hoverOpacity?: number;
+    hoverWidth?: number;
+    originalPaint?: any;
+    originalLayout?: any;
+}
+type OffHandler = () => void;
+export declare class HoverManager {
+    private map;
+    private hoveredLayers;
+    private isEnabled;
+    private debounceTimers;
+    private debounceDelay;
+    private cleanupFunctions;
+    constructor(map: MaplibreMap);
+    setDebounceDelay(delay: number): void;
+    private resolveArray;
+    private arrayifyAndOff;
+    hoverLayer: (layers: LayerRef, cb: (e: any) => void) => void;
+    hoverPopup(layers: LayerRef, htmlFunc: HtmlFunction, popupOptions?: PopupOptions): OffHandler;
+}
+export {};

package/dist/managers/LayerManager.d.ts

@@ -0,0 +1,33 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+import type { LayerConfig, ILayerManager, LODConfig } from "../types";
+import { TYPEMAP } from "../constants/builtin-layers";
+import { PerformanceManager } from "./PerformanceManager";
+export declare class LayerManager implements ILayerManager {
+    private map;
+    private customLayers;
+    private builtInLayers;
+    private performanceManager;
+    private customLayerStyles;
+    constructor(map: MaplibreMap, performanceManager?: PerformanceManager, customLayerStyles?: Record<string, any>);
+    private initializeBuiltInLayers;
+    addLayer(layer: LayerConfig): string;
+    removeLayer(layerId: string): boolean;
+    updateLayer(layerId: string, updates: Partial<LayerConfig>): boolean;
+    showLayer(layerId: string): boolean;
+    hideLayer(layerId: string): boolean;
+    toggleLayer(layerId: string): boolean;
+    getLayer(layerId: string): LayerConfig | undefined;
+    getAllLayers(): LayerConfig[];
+    batchUpdateLayers(updates: Array<{
+        id: string;
+        updates: Partial<LayerConfig>;
+    }>): void;
+    batchShowLayers(layerIds: string[]): void;
+    batchHideLayers(layerIds: string[]): void;
+    addBuiltInLayer(layerName: string | Array<string>, zindex: string): Promise<void>;
+    removeBuiltInLayer(layerName: string): boolean;
+    getBuiltInLayers(): typeof TYPEMAP;
+    isBuiltInLayerVisible(layerId: string): boolean;
+    setLODEnabled(enabled: boolean): void;
+    setLayerLODConfig(layerId: string, config: LODConfig): void;
+}

package/dist/managers/LineLabelOptimizer.d.ts

@@ -0,0 +1,38 @@
+import maplibregl from 'maplibre-gl';
+interface LineLabelOptions {
+    builtInKey: string;
+    lineLayerId: string;
+    lineLabelId: string;
+    fieldList: string[];
+    suffix?: string;
+}
+export declare class LineLabelOptimizer {
+    private map;
+    private builtInKey;
+    private lineLayerId;
+    private lineLabelId;
+    private suffix;
+    private fieldList;
+    private originalLabelLayer;
+    private callback;
+    private originalLayerList;
+    private boundExecute;
+    private isActive;
+    private boundOnStyleData;
+    private lastLineLayerVisibility;
+    constructor(map: maplibregl.Map, callback: Function);
+    get labelOptions(): LineLabelOptions;
+    set labelOptions(options: LineLabelOptions);
+    private getLineLayerVisibility;
+    private onStyleDataChange;
+    private handleLineLayerVisibilityChange;
+    private hideOriginalLabelLayer;
+    private showOriginalLabelLayer;
+    private hideDeduplicatedLabelLayer;
+    private showDeduplicatedLabelLayer;
+    private execute;
+    update(): void;
+    remove(): void;
+    private cloneLayerStyle;
+}
+export {};

package/dist/managers/NotamManager.d.ts

@@ -0,0 +1,40 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+import { HoverManager } from "./HoverManage";
+import { ClickManager } from "./ClickManager";
+import API from "../apis";
+export declare class NOTAM {
+    private map;
+    private readonly sourceLineId;
+    private readonly sourceFillId;
+    private readonly lineLayerId;
+    private readonly fillLayerId;
+    private readonly labelLayerId;
+    private opened;
+    hoverManager: HoverManager;
+    clickManager: ClickManager;
+    private _lineHoveredStateId;
+    private _fillHoveredStateId;
+    private beforeId;
+    api: API;
+    constructor(map: MaplibreMap);
+    defaultParams: {
+        pageNo: number;
+        pageSize: number;
+        onlyGeojson: boolean;
+        typeC: boolean;
+        notamOffset: string;
+        isInternational: boolean;
+        isCompanyVersion: boolean;
+    };
+    open(builtin: Boolean, lineLayerConfig?: any, fillLayerConfig?: any, isPattern?: boolean): void;
+    close(): void;
+    update(features: any): void;
+    hover(callback: (e: any) => void): void;
+    refresh(): void;
+    destroy(): void;
+    getNotamData(params?: any): Promise<any>;
+    openNotamDetail(): void;
+    private _getNotamData;
+    private isObject;
+    private mergeLayerConfig;
+}

package/dist/managers/PerformanceManager.d.ts

@@ -0,0 +1,40 @@
+import type { LODConfig, ClusteringConfig, LayerConfig } from '../types';
+export declare class PerformanceManager {
+    private lodEnabled;
+    private clusteringEnabled;
+    private lazyLoadingEnabled;
+    private layerLODConfigs;
+    private clusteringConfigs;
+    private visibleLayers;
+    private layerLoadQueue;
+    private isProcessingQueue;
+    constructor(options?: {
+        lodEnabled?: boolean;
+        clusteringEnabled?: boolean;
+        lazyLoadingEnabled?: boolean;
+    });
+    setLODEnabled(enabled: boolean): void;
+    setLayerLODConfig(layerId: string, config: LODConfig): void;
+    getLayerLODConfig(layerId: string): LODConfig | undefined;
+    setClusteringEnabled(enabled: boolean): void;
+    setClusteringConfig(layerId: string, config: ClusteringConfig): void;
+    getClusteringConfig(layerId: string): ClusteringConfig | undefined;
+    setLazyLoadingEnabled(enabled: boolean): void;
+    addToLazyLoadQueue(layerId: string, priority?: number): void;
+    private processLoadQueue;
+    private loadLayer;
+    private simulateLayerLoading;
+    private delay;
+    shouldLayerBeVisible(layerId: string, currentZoom: number): boolean;
+    getPerformanceStats(): {
+        visibleLayers: number;
+        queuedLayers: number;
+        lodEnabled: boolean;
+        clusteringEnabled: boolean;
+        lazyLoadingEnabled: boolean;
+    };
+    optimizeLayerConfig(layer: LayerConfig, currentZoom: number): LayerConfig;
+    private simplifyPaintProperties;
+    private simplifyLayoutProperties;
+    destroy(): void;
+}

package/dist/managers/PluginManager.d.ts

@@ -0,0 +1,17 @@
+import type { IPlugin, IMapSDK } from '../types';
+export declare class PluginManager {
+    private plugins;
+    private sdk;
+    constructor(sdk: IMapSDK);
+    use(plugin: IPlugin): void;
+    getPlugin<T extends IPlugin>(name: string): T | undefined;
+    getAllPlugins(): IPlugin[];
+    hasPlugin(name: string): boolean;
+    uninstallPlugin(name: string): boolean;
+    uninstallAllPlugins(): void;
+    getPluginStats(): {
+        total: number;
+        names: string[];
+    };
+    destroy(): void;
+}

package/dist/managers/PopupManager.d.ts

@@ -0,0 +1,2 @@
+import { Popup } from "maplibre-gl";
+export { Popup };

package/dist/managers/RasterManager.d.ts

@@ -0,0 +1,16 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+export declare class RasterManager {
+    private map;
+    private rasterUrl;
+    private coordinates;
+    private readonly MAX_LAT;
+    constructor(map: MaplibreMap);
+    get rasterSourceUrl(): string;
+    set rasterSourceUrl(url: string);
+    private updateCoordinates;
+    private addSource;
+    private addLayer;
+    addRasterLayer(layerId: string, sourceId: string, meteoType: string): void;
+    updateRasterLayer(sourceId: string, newUrl: string, meteoType: string): void;
+    removeRasterLayer(layerId: string, sourceId: string): void;
+}

package/dist/managers/SelectFeature.d.ts

@@ -0,0 +1,34 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+interface SelectFeatureOptions {
+    isHighlight: boolean;
+    highlightColor: string;
+    fillOpacity: number;
+    circleRadius: number;
+    tolerance: number;
+    multiSelect: boolean;
+    lineWidth: number;
+    onSelect: ((lngLat: {
+        lng: number;
+        lat: number;
+    }, feature: any, selectedFeatures: any[]) => void) | null;
+    onContextMenu: ((feature: any, properties: any) => void) | null;
+}
+export declare class SelectFeature {
+    private map;
+    private options;
+    private highlightSourceId;
+    private selectedFeatures;
+    private selectLayerIds;
+    constructor(map: MaplibreMap);
+    setSelectLayers(layerIds: string[] | null): void;
+    setOptions(options: Partial<SelectFeatureOptions>): void;
+    enable(): void;
+    disable(): void;
+    removeSelectedFeatures(): void;
+    removeHighlightLayersOnly(): void;
+    getSelected(): any[];
+    _updateHighlightLayer(): void;
+    _onClick(e: maplibregl.MapMouseEvent): void;
+    _onContextMenu(e: MouseEvent): boolean;
+}
+export {};

package/dist/managers/ThemeManage.d.ts

@@ -0,0 +1,11 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+export declare class Theme {
+    private map;
+    constructor(map: MaplibreMap);
+    private ARRAY_STYLE_KEYS;
+    layerExists: (layerId: string) => boolean;
+    applyLayerStyle(layerId: string, style: any, checkLayerExists?: boolean): void;
+    handleNormalLayers(customStyle: any): void;
+    handleArrayLayers(customStyle: any): void;
+    setStyle: (customStyle: any) => void;
+}

package/dist/managers/WindManager.d.ts

@@ -0,0 +1,21 @@
+import type { Map as MaplibreMap } from "maplibre-gl";
+export interface WindFrame {
+    refTime: string;
+    uUrl: string;
+    vUrl: string;
+}
+export interface WindOptions {
+    numParticles?: number;
+    speedFactor?: number;
+    dataRange?: number;
+}
+export declare class WindManager {
+    private map;
+    private options;
+    private _visible;
+    constructor(map: MaplibreMap, options?: WindOptions);
+    get visible(): boolean;
+    open(frame?: WindFrame): void;
+    setFrame(frame: WindFrame): void;
+    close(): void;
+}