deeptwins-engine-3d 0.1.63 → 0.1.65

package/dist/esm/tileLayer/MvtVectorLoad.d.ts

@@ -0,0 +1,241 @@
+import * as Cesium from 'deeptwins-cesium';
+import { MapContext } from '../map/Map';
+type TileState = 'none' | 'loading' | 'loaded' | 'error';
+interface VectorLoadOptions {
+    url: string;
+    minzoom?: number;
+    maxzoom?: number;
+    maxCacheSize?: number;
+    autoDisplayLayers?: boolean;
+    decodeWithWorker?: boolean;
+    workerUrl?: string;
+}
+type DecodedTileCoordinate = [number, number] | [number, number, number];
+interface DecodedPointGeometry {
+    type: 'Point';
+    coordinates: DecodedTileCoordinate;
+}
+interface DecodedMultiPointGeometry {
+    type: 'MultiPoint';
+    coordinates: DecodedTileCoordinate[];
+}
+interface DecodedLineStringGeometry {
+    type: 'LineString';
+    coordinates: DecodedTileCoordinate[];
+}
+interface DecodedMultiLineStringGeometry {
+    type: 'MultiLineString';
+    coordinates: DecodedTileCoordinate[][];
+}
+interface DecodedPolygonGeometry {
+    type: 'Polygon';
+    coordinates: DecodedTileCoordinate[][];
+}
+interface DecodedMultiPolygonGeometry {
+    type: 'MultiPolygon';
+    coordinates: DecodedTileCoordinate[][][];
+}
+type DecodedTileGeometry = DecodedPointGeometry | DecodedMultiPointGeometry | DecodedLineStringGeometry | DecodedMultiLineStringGeometry | DecodedPolygonGeometry | DecodedMultiPolygonGeometry;
+interface DecodedTileFeature {
+    type: 'Feature';
+    id: number;
+    properties: Record<string, unknown>;
+    geometry: DecodedTileGeometry;
+}
+interface DecodedTile {
+    version: number;
+    z: number;
+    x: number;
+    y: number;
+    features: DecodedTileFeature[];
+}
+interface LoadedTile {
+    x: number;
+    y: number;
+    z: number;
+    raw: DecodedTile;
+}
+interface EvictedTile {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+}
+interface TileDisplayChange {
+    key: string;
+    x: number;
+    y: number;
+    z: number;
+    display: 'show' | 'hide';
+}
+interface ManagedTileLayer {
+    show(isShow: boolean): void;
+    remove(): void;
+    isDestroyed?: boolean | (() => boolean);
+}
+type TileLoadLayerResult = ManagedTileLayer | ManagedTileLayer[] | void | null;
+type TileLoadLayerHandlerResult = TileLoadLayerResult | Promise<TileLoadLayerResult>;
+declare const MVT_VECTOR_LOAD_EVENT_TYPES: readonly ["ready", "error", "tileLoad", "tileDisplay", "tileEvict"];
+type MvtVectorLoadEventType = (typeof MVT_VECTOR_LOAD_EVENT_TYPES)[number];
+interface MvtVectorLoadEventHandlerMap {
+    ready(loader: MvtVectorLoad): void;
+    error(error: Error): void;
+    tileLoad(tile: LoadedTile): TileLoadLayerHandlerResult;
+    tileDisplay(change: TileDisplayChange): void;
+    tileEvict(tile: EvictedTile): void;
+}
+interface MvtVectorLoadEventSubscription {
+    off(): void;
+}
+interface TileGeoJSONResult {
+    x: number;
+    y: number;
+    z: number;
+    geoJson: {
+        type: 'FeatureCollection';
+        features: DecodedTileFeature[];
+    };
+}
+interface FrameStateLike {
+    context: {
+        drawingBufferHeight: number;
+    };
+    camera: {
+        frustum: {
+            sseDenominator: number;
+        };
+    };
+    fog: {
+        enabled: boolean;
+        density: number;
+        sse: number;
+    };
+    pixelRatio: number;
+    maximumScreenSpaceError: number;
+    cullingVolume: {
+        computeVisibility: (boundingVolume: unknown) => Cesium.Intersect;
+    };
+}
+interface TileBoundingRegionLike {
+    distanceToCamera(frameState: FrameStateLike): number;
+}
+interface VectorLoadTileOptions {
+    x: number;
+    y: number;
+    z: number;
+    tilingScheme: Cesium.WebMercatorTilingScheme;
+    parent: MvtVectorLoad;
+}
+interface TileVisitor {
+    visitChildren(tile: VectorLoadTile): void;
+    accept(tile: VectorLoadTile): void;
+}
+type ScreenSpaceErrorCalculator = (frameState: FrameStateLike, tile: VectorLoadTile) => number;
+declare class MvtVectorLoad {
+    private readonly _mapContext;
+    url: string;
+    minzoom: number;
+    maximumLevel: number;
+    maxCacheSize: number;
+    ready: boolean;
+    zoom: number;
+    readonly tilingScheme: Cesium.WebMercatorTilingScheme;
+    readonly readyEvent: Cesium.Event<(loader: MvtVectorLoad) => void>;
+    readonly errorEvent: Cesium.Event<(error: Error) => void>;
+    readonly tileLoadEvent: Cesium.Event<(tile: LoadedTile) => TileLoadLayerHandlerResult>;
+    readonly tileDisplayEvent: Cesium.Event<(change: TileDisplayChange) => void>;
+    readonly tileEvictEvent: Cesium.Event<(tile: EvictedTile) => void>;
+    _destroyed: boolean;
+    _initPromise: Promise<MvtVectorLoad> | null;
+    _rootTiles: VectorLoadTile[];
+    _tilesToUpdate: VectorLoadTile[];
+    _loadedTiles: Record<string, LoadedTile>;
+    _pendingTiles: Map<string, Promise<LoadedTile>>;
+    private _cacheOrder;
+    _requestToken: number;
+    private _levelZeroMaximumGeometricError;
+    private _decodeWithWorker;
+    private _autoDisplayLayers;
+    private _workerUrl;
+    private _decodeWorkerClient;
+    private _listenerRegistry;
+    private _displayedTiles;
+    private _managedTileLayers;
+    private _addedToMap;
+    constructor(map: MapContext, options?: Partial<VectorLoadOptions>);
+    getMap(): any;
+    private _addToMap;
+    private _removeFromMap;
+    init(): Promise<MvtVectorLoad>;
+    on<K extends MvtVectorLoadEventType>(type: K, handler: MvtVectorLoadEventHandlerMap[K]): MvtVectorLoadEventSubscription;
+    private _wrapEventHandler;
+    off<K extends MvtVectorLoadEventType>(type: K, handler: MvtVectorLoadEventHandlerMap[K]): void;
+    private _getEventByType;
+    private _createInvalidEventTypeError;
+    private _removeRegisteredListener;
+    private _clearListenerRegistry;
+    private _doInit;
+    private _validateOptions;
+    private _emitError;
+    private _createRootTiles;
+    private _getTileKey;
+    private _touchTileCache;
+    private _pruneLoadedTiles;
+    private _getTilesToUpdate;
+    private _toDisplayedTileState;
+    private _isTileLoaded;
+    private _isSameOrAncestorTile;
+    private _tilesOverlap;
+    private _shouldKeepDisplayedTile;
+    private _shouldDelayTargetTileDisplay;
+    private _raiseTileDisplayChange;
+    private _syncTileDisplayState;
+    private _hideAllDisplayedTiles;
+    private _isManagedTileLayer;
+    private _normalizeManagedTileLayers;
+    private _registerManagedTileLayers;
+    private _isManagedTileLayerDestroyed;
+    private _applyManagedTileLayersDisplay;
+    private _setManagedTileLayersDisplay;
+    private _removeManagedTileLayers;
+    private _removeAllManagedTileLayers;
+    private _getLevelMaximumGeometricError;
+    private _resetTileStatesByKeys;
+    private _getScreenSpaceError;
+    private _buildTileUrl;
+    private _toError;
+    private _getDecodeWorkerClient;
+    private _destroyDecodeWorkerClient;
+    private _decodeTile;
+    private _requestTile;
+    private _loadTile;
+    tileToGeoJSON(tile: LoadedTile): TileGeoJSONResult;
+    update(frameState: FrameStateLike): void;
+    private _updateTiles;
+    private _loadVisibleTile;
+    getLoadedTiles(): LoadedTile[];
+    getTile(x: number, y: number, z: number): LoadedTile | undefined;
+    clearCache(): void;
+    private _resetTileStates;
+    destroy(): void;
+    isDestroyed(): boolean;
+}
+declare class VectorLoadTile {
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    readonly key: string;
+    readonly parent: MvtVectorLoad;
+    readonly tilingScheme: Cesium.WebMercatorTilingScheme;
+    readonly rectangle: Cesium.Rectangle;
+    readonly tileBoundingRegion: TileBoundingRegionLike;
+    readonly children: VectorLoadTile[];
+    distanceToCamera: number;
+    visibility: Cesium.Intersect;
+    state: TileState;
+    constructor(options: VectorLoadTileOptions);
+    createChildren(): void;
+    visit(frameState: FrameStateLike, visitor: TileVisitor, getScreenSpaceError: ScreenSpaceErrorCalculator): void;
+}
+export type { EvictedTile, LoadedTile, ManagedTileLayer, MvtVectorLoadEventHandlerMap, MvtVectorLoadEventSubscription, MvtVectorLoadEventType, TileDisplayChange, TileGeoJSONResult, TileLoadLayerHandlerResult, TileLoadLayerResult, };
+export default MvtVectorLoad;