@maptalks/vt 0.107.4 → 0.108.0

package/dist/maptalks.vt.d.ts

@@ -1,11 +1,11 @@
 /*!
- * @maptalks/vt v0.107.4
+ * @maptalks/vt v0.108.0
  * LICENSE : undefined
  * (c) 2016-2025 maptalks.org
  */
 import * as maptalks from 'maptalks';
 import { FillSymbol, LineSymbol, MarkerCommonSymbol, TextSymbol, LayerIdentifyOptionsType, TileLayerOptionsType, LayerJSONType, OverlayLayerOptionsType } from 'maptalks';
-import { reshader, GroundPainter, createREGL } from '@maptalks/gl';
+import { reshader, GroundPainter } from '@maptalks/gl';
 
 interface FillDataConfig {
     type?: "fill";
@@ -102,6 +102,8 @@ interface BackgroundConfig {
 declare class VectorTileLayer extends maptalks.TileLayer {
     VERSION: string;
     ready: boolean;
+    isVectorTileLayer: boolean;
+    hasTerrainMask: boolean;
     options: VectorTileLayerOptionsType;
     static loadFrom(url: string, fetchOptions: Record<string, any>): Promise<VectorTileLayer>;
     constructor(id: string, options: VectorTileLayerOptionsType);
@@ -701,7 +703,432 @@ declare class TileStencilRenderer {
     remove(): void;
 }
 
-declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasRenderer {
+declare const VectorTileLayerRenderer_base: (new (...args: any[]) => {
+    [x: string]: any;
+    createContext(): void;
+    clearContext(): void;
+}) & (new (...args: any[]) => {
+    [x: string]: any;
+    tilesInView: maptalks.TilesInViewType;
+    tilesLoading: {
+        [key: string]: any;
+    };
+    _parentTiles: any[];
+    _childTiles: any[];
+    _tileZoom: number;
+    _tileQueue: {
+        tileInfo: any;
+        tileData: any;
+    }[];
+    _tileQueueIds: Set<maptalks.LayerId>;
+    tileCache: maptalks.LRUCache;
+    _compareTiles: any;
+    _tileImageWorkerConn: {
+        checkUrl(url: string): string;
+        fetchImage(url: string, workerId: number, cb: Function, fetchOptions: any): void;
+        initializing: boolean;
+        workerKey: string;
+        workerPool: {
+            active: {
+                [key: number]: boolean;
+            };
+            workerCount: number;
+            workers: Worker[];
+            acquire(id: number): Worker[];
+            release(id: number): void;
+            addMessage(workerId: number, data: any, buffers: ArrayBuffer[]): void;
+            commit(): void;
+            getWorkers(): Worker[];
+            broadcastIdleMessage(messageRatio: number): any;
+        };
+        currentActor: number;
+        actorId: number;
+        workers: Worker[];
+        callbacks: {
+            [key: string]: Function;
+        };
+        callbackID: number;
+        receiveFn: any;
+        created(): void;
+        isActive(): boolean;
+        broadcast<T = any>(data: T, buffers: ArrayBuffer[], cb: Function): any;
+        send<T_1 = any>(data: T_1, buffers: ArrayBuffer[], cb: Function, workerId?: number): any;
+        receive(message: maptalks.Message<any>): void;
+        remove(): void;
+        post(data: any, buffers: ArrayBuffer[], targetID: number): number;
+        getDedicatedWorker(): number;
+    };
+    _renderTimestamp: number;
+    _frameTiles: {
+        empty: boolean;
+        timestamp: number;
+    };
+    _terrainHelper: any;
+    _tilePlaceHolder: any;
+    _frameTileGrids: maptalks.TileGrids;
+    drawingCurrentTiles: boolean;
+    drawingChildTiles: boolean;
+    drawingParentTiles: boolean;
+    avgMinAltitude: number;
+    avgMaxAltitude: number;
+    init(): void;
+    getCurrentTileZoom(): number;
+    draw(timestamp: number, context: any): number;
+    getTileGridsInCurrentFrame(): maptalks.TileGrids;
+    getCurrentTimestamp(): number;
+    _getTilesInCurrentFrame(): {
+        childTiles: any[];
+        missedTiles: any[];
+        parentTiles: any[];
+        tiles: any[];
+        incompleteTiles: unknown[];
+        placeholders: any[];
+        loading: boolean;
+        loadingCount: number;
+        tileQueue: {};
+    };
+    removeTileCache(tileId: string): void;
+    isTileCachedOrLoading(tileId: string): any;
+    isTileCached(tileId: string): boolean;
+    isTileFadingIn(tileImage: maptalks.TileImage): boolean;
+    _drawTiles(tiles: any, parentTiles: any, childTiles: any, placeholders: any, parentContext: any, missedTiles: any, incompleteTiles: any): void;
+    _drawChildTiles(childTiles: any, parentContext: any): void;
+    _drawParentTiles(parentTiles: any, parentContext: any): void;
+    onDrawTileStart(context: any, parentContext: any): void;
+    onDrawTileEnd(context: any, parentContext: any): void;
+    _drawTile(info: any, image: any, parentContext: any): void;
+    drawTile(tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }, tileImage: maptalks.TileImage, parentContext?: any): void;
+    _drawTileAndCache(tile: maptalks.Tile, parentContext: any): void;
+    drawOnInteracting(event: any, timestamp: number, context: any): void;
+    checkIfNeedRedraw(): boolean;
+    hitDetect(): boolean;
+    _getLoadLimit(): number;
+    _isLoadingTile(tileId: string): boolean;
+    loadTileQueue(tileQueue: any): void;
+    loadTile(tile: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): maptalks.TileImage;
+    _fetchImage(image: any, tile: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    loadTileImage(tileImage: any, url: string, tile: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    abortTileLoading(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    onTileLoad(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    removeTileLoading(tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    _consumeTileQueue(): void;
+    _computeAvgTileAltitude(): void;
+    checkTileInQueue(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): boolean;
+    consumeTile(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): void;
+    resetTileLoadTime(tileImage: maptalks.TileImage): void;
+    onTileError(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }, error?: any): void;
+    getDebugInfo(tileId: string): string;
+    findChildTiles(info: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): any;
+    _findChildTiles(info: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): any;
+    _findChildTilesAt(children: maptalks.Tile[], pmin: number, pmax: number, layer: any, childZoom: number): void;
+    findParentTile(info: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }, targetDiff?: number): maptalks.Tile;
+    _findParentTile(info: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }, targetDiff?: number): maptalks.Tile;
+    isValidCachedTile(tile: maptalks.Tile): boolean;
+    isTileComplete(tile: maptalks.Tile): boolean;
+    _getLayerOfTile(layerId: maptalks.LayerId): any;
+    getCachedTile(tile: maptalks.Tile, isParent: boolean): any;
+    _addTileToCache(tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }, tileImage: maptalks.TileImage): void;
+    getTileOpacity(tileImage: maptalks.TileImage, tileInfo: {
+        x: number;
+        y: number;
+        z: number;
+        idx: number;
+        idy: number;
+        id: string;
+        layer: string | number;
+        children: [];
+        error: number;
+        offset: [number, number];
+        extent2d: maptalks.Extent;
+        res: number;
+        url: string;
+        parent: any;
+        cache?: boolean;
+        minAltitude?: number;
+        maxAltitude?: number;
+    }): number;
+    getTileFadingOpacity(tileImage: maptalks.TileImage): number;
+    clearTileCaches(): void;
+    removeTileCaches(): void;
+    markCurrent(tile: maptalks.Tile, isCurrent?: boolean): void;
+    markTiles(): number[];
+    retireTiles(force?: boolean): void;
+    deleteTile(tile: maptalks.Tile): void;
+    _generatePlaceHolder(res: number): HTMLCanvasElement;
+    setTerrainHelper(helper: any): void;
+    _validateTileImage(image: any): boolean;
+}) & typeof maptalks.renderer.LayerAbstractRenderer;
+declare class VectorTileLayerRenderer extends VectorTileLayerRenderer_base {
     constructor(layer: any);
     supportRenderMode(): boolean;
     _workerCacheIndex: number;
@@ -723,23 +1150,20 @@ declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasR
     updateDataConfig(type: any, idx: any, dataConfig: any, old: any): void;
     updateSymbol(type: any, idx: any, symbol: any): any;
     needRetireFrames(): boolean;
+    getCurrentTiles(): {};
     isAnimating(): boolean;
     _highlightFrametime: any;
     needToRefreshTerrainTileOnZooming(): boolean;
-    _isInGroupGLLayer(): boolean;
     regl: any;
-    glOptions: any;
+    gl: any;
+    device: any;
     pickingFBO: any;
     _debugPainter: DebugPainter;
     _groundPainter: GroundPainter;
-    _createREGLContext(canvas: any): {
-        gl: any;
-        attributes: any;
-        regl: createREGL.Regl;
-    };
     _prepareWorker(): void;
     _workerConn: WorkerConnection;
     _incrWorkerCacheIndex(): void;
+    isDrawable(): boolean;
     checkResources(): any[];
     _drawTiles(tiles: any, parentTiles: any, childTiles: any, placeholders: any, context: any): void;
     _deletePrevPlugins(): void;
@@ -758,7 +1182,6 @@ declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasR
     getAnalysisMeshes(): any[];
     getShadowMeshes(): any[];
     isForeground(mesh: any): boolean;
-    getCurrentTiles(): {};
     _getTileZoomDiff(mesh: any): number;
     isTileNearCamera(mesh: any): boolean;
     isBackTile(id: any): boolean;
@@ -826,7 +1249,7 @@ declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasR
     _getPluginContext(plugin: any, polygonOffsetIndex: any, cameraPosition: any, timestamp: any): {
         regl: any;
         layer: any;
-        gl: maptalks.TileRenderingContext;
+        gl: any;
         isRenderingTerrain: any;
         isRenderingTerrainSkin: any;
         sceneConfig: any;
@@ -852,6 +1275,7 @@ declare class VectorTileLayerRenderer extends maptalks.renderer.TileLayerCanvasR
     _terrainDepthStencil: any;
     deleteTerrainTexture(texture: any): void;
     renderTerrainSkin(terrainRegl: any, terrainLayer: any, skinImages: any): void;
+    isRenderingTerrainSkin: boolean;
     _drawTerrainTile(tile: any): void;
     _endTerrainFrame(skinImages: any): void;
     drawTile(tileInfo: any, tileData: any, filter: any): void;