astro-viewer 3.0.0 → 3.2.0

package/lib-esm/model/earth/XYZTileBuffer.d.ts

@@ -1,39 +1,37 @@
-import { XYZShaderProgram } from '../../shader/XYZShaderProgram.js';
-import { XYZMeshBuilder } from './XYZMeshBuilder.js';
-import { XYZTile } from './XYZTile.js';
-import type { XYZTileCoord } from './types.js';
-export type XYZTileRequest = {
-    tileCoord: XYZTileCoord;
-    url: string;
-    priority: number;
-    role: 'current' | 'coverage' | 'fallback' | 'base';
+import type { XYZTileCoord } from './XYZTypes.js';
+export type XYZBufferedTile = {
+    coord: XYZTileCoord;
+    loading?: boolean;
+    lastUsedAt?: number;
+    createdAt?: number;
+    touch?: () => void;
+    dispose?: () => void;
 };
-type XYZTileBufferEntry = {
-    tile: XYZTile;
+export type XYZTileBufferEntry<TTile extends XYZBufferedTile = XYZBufferedTile> = {
+    tile: TTile;
     cacheTime0?: number;
-    role: 'current' | 'coverage' | 'fallback' | 'base';
 };
-export declare class XYZTileBuffer {
+export type XYZTileFactory<TTile extends XYZBufferedTile = XYZBufferedTile> = (coord: XYZTileCoord) => TTile;
+export declare class XYZTileBuffer<TTile extends XYZBufferedTile = XYZBufferedTile> {
     private _tiles;
     private _cachedTiles;
     private _cacheAliveMilliSeconds;
     private _cleanerId;
-    private _webgl;
-    private _meshBuilder;
-    private _shaderProgram;
-    constructor(minutesToLiveInCache: number | undefined, webgl: WebGL2RenderingContext, meshBuilder: XYZMeshBuilder, shaderProgram: XYZShaderProgram);
-    get activeTiles(): Map<string, XYZTileBufferEntry>;
-    get cachedTiles(): Map<string, XYZTileBufferEntry>;
+    constructor(minutesToLiveInCache?: number);
+    get activeTiles(): Map<string, XYZTileBufferEntry<TTile>>;
+    get cachedTiles(): Map<string, XYZTileBufferEntry<TTile>>;
     get size(): number;
-    getTile(tileCoord: XYZTileCoord, url: string, segmentsPerSide: number, role: 'current' | 'coverage' | 'fallback' | 'base'): XYZTile;
-    private getExistingTile;
-    ensureTiles(requests: XYZTileRequest[], segmentsPerSide: number): string[];
-    getActiveTile(tileKey: string): XYZTile | null;
-    getAnyTile(tileKey: string): XYZTile | null;
+    ensureTiles(visibleTiles: XYZTileCoord[], tileFactory: XYZTileFactory<TTile>): string[];
+    getTile(tileCoord: XYZTileCoord, tileFactory: XYZTileFactory<TTile>): TTile;
+    getActiveTile(tileKey: string): TTile | null;
+    getAnyTile(tileKey: string): TTile | null;
+    getActiveTiles(): TTile[];
     syncVisibleTiles(visibleTileKeys: string[]): void;
     evictCached(maxCachedTiles: number): void;
     dispose(): void;
+    key(tileCoord: XYZTileCoord): string;
+    static key(tileCoord: XYZTileCoord): string;
     private cacheCleaner;
-    private key;
+    private touchTile;
+    private getTileAgeScore;
 }
-export {};

package/lib-esm/model/earth/XYZTileBuffer.js

@@ -1,20 +1,27 @@
-import { XYZTile } from './XYZTile.js';
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 export class XYZTileBuffer {
     _tiles = new Map();
     _cachedTiles = new Map();
     _cacheAliveMilliSeconds;
     _cleanerId;
-    _webgl;
-    _meshBuilder;
-    _shaderProgram;
-    constructor(minutesToLiveInCache = 1, webgl, meshBuilder, shaderProgram) {
+    constructor(minutesToLiveInCache = 1) {
         this._cacheAliveMilliSeconds = minutesToLiveInCache * 60 * 1000;
-        this._webgl = webgl;
-        this._meshBuilder = meshBuilder;
-        this._shaderProgram = shaderProgram;
-        this._cleanerId = window.setInterval(() => {
-            this.cacheCleaner();
-        }, 10_000);
+        if (typeof window !== 'undefined') {
+            this._cleanerId = window.setInterval(() => {
+                this.cacheCleaner();
+            }, 10_000);
+        }
     }
     get activeTiles() {
         return this._tiles;
@@ -25,64 +32,31 @@ export class XYZTileBuffer {
     get size() {
         return this._tiles.size + this._cachedTiles.size;
     }
-    getTile(tileCoord, url, segmentsPerSide, role) {
-        const tileKey = this.key(tileCoord);
-        if (!this._tiles.has(tileKey)) {
-            if (this._cachedTiles.has(tileKey)) {
-                const entry = this._cachedTiles.get(tileKey);
-                entry.cacheTime0 = undefined;
-                entry.role = role;
-                this._tiles.set(tileKey, entry);
-                this._cachedTiles.delete(tileKey);
-            }
-            else {
-                const mesh = this._meshBuilder.buildTileMesh(tileCoord, segmentsPerSide);
-                this._tiles.set(tileKey, {
-                    tile: new XYZTile(tileCoord, url, mesh, this._webgl, this._shaderProgram),
-                    role,
-                });
-            }
-        }
-        else {
-            const entry = this._tiles.get(tileKey);
-            entry.role = role;
+    ensureTiles(visibleTiles, tileFactory) {
+        const visibleTileKeys = [];
+        for (const tileCoord of visibleTiles) {
+            const tile = this.getTile(tileCoord, tileFactory);
+            this.touchTile(tile);
+            visibleTileKeys.push(this.key(tileCoord));
         }
-        return this._tiles.get(tileKey).tile;
+        this.syncVisibleTiles(visibleTileKeys);
+        return visibleTileKeys;
     }
-    getExistingTile(tileCoord, role) {
+    getTile(tileCoord, tileFactory) {
         const tileKey = this.key(tileCoord);
         if (this._tiles.has(tileKey)) {
-            const entry = this._tiles.get(tileKey);
-            entry.role = role;
-            return entry.tile;
+            return this._tiles.get(tileKey).tile;
         }
         if (this._cachedTiles.has(tileKey)) {
             const entry = this._cachedTiles.get(tileKey);
             entry.cacheTime0 = undefined;
-            entry.role = role;
             this._tiles.set(tileKey, entry);
             this._cachedTiles.delete(tileKey);
             return entry.tile;
         }
-        return null;
-    }
-    ensureTiles(requests, segmentsPerSide) {
-        const visibleTileKeys = [];
-        for (const request of requests) {
-            const tile = request.role === 'fallback'
-                ? this.getExistingTile(request.tileCoord, 'fallback')
-                : this.getTile(request.tileCoord, request.url, segmentsPerSide, request.role);
-            if (!tile) {
-                continue;
-            }
-            tile.touch();
-            if (request.role !== 'fallback') {
-                tile.primeLoad(request.priority);
-            }
-            visibleTileKeys.push(this.key(request.tileCoord));
-        }
-        this.syncVisibleTiles(visibleTileKeys);
-        return visibleTileKeys;
+        const tile = tileFactory(tileCoord);
+        this._tiles.set(tileKey, { tile });
+        return tile;
     }
     getActiveTile(tileKey) {
         return this._tiles.get(tileKey)?.tile ?? null;
@@ -90,11 +64,14 @@ export class XYZTileBuffer {
     getAnyTile(tileKey) {
         return this._tiles.get(tileKey)?.tile ?? this._cachedTiles.get(tileKey)?.tile ?? null;
     }
+    getActiveTiles() {
+        return Array.from(this._tiles.values(), (entry) => entry.tile);
+    }
     syncVisibleTiles(visibleTileKeys) {
         const visibleKeySet = new Set(visibleTileKeys);
         for (const [tileKey, entry] of this._tiles) {
             if (visibleKeySet.has(tileKey)) {
-                entry.tile.touch();
+                this.touchTile(entry.tile);
                 continue;
             }
             entry.cacheTime0 = Date.now();
@@ -107,9 +84,7 @@ export class XYZTileBuffer {
             return;
         }
         const candidates = Array.from(this._cachedTiles.entries()).sort((a, b) => {
-            const scoreA = Math.min(a[1].tile.lastUsedAt || a[1].tile.createdAt, a[1].tile.createdAt);
-            const scoreB = Math.min(b[1].tile.lastUsedAt || b[1].tile.createdAt, b[1].tile.createdAt);
-            return scoreA - scoreB;
+            return this.getTileAgeScore(a[1].tile) - this.getTileAgeScore(b[1].tile);
         });
         for (const [tileKey, entry] of candidates) {
             if (this.size <= maxCachedTiles) {
@@ -118,32 +93,47 @@ export class XYZTileBuffer {
             if (entry.tile.loading) {
                 continue;
             }
-            entry.tile.dispose();
+            entry.tile.dispose?.();
             this._cachedTiles.delete(tileKey);
         }
     }
     dispose() {
-        window.clearInterval(this._cleanerId);
+        if (this._cleanerId !== undefined && typeof window !== 'undefined') {
+            window.clearInterval(this._cleanerId);
+            this._cleanerId = undefined;
+        }
         for (const entry of this._tiles.values()) {
-            entry.tile.dispose();
+            entry.tile.dispose?.();
         }
         for (const entry of this._cachedTiles.values()) {
-            entry.tile.dispose();
+            entry.tile.dispose?.();
         }
         this._tiles.clear();
         this._cachedTiles.clear();
     }
+    key(tileCoord) {
+        return XYZTileBuffer.key(tileCoord);
+    }
+    static key(tileCoord) {
+        return `${tileCoord.z}/${tileCoord.x}/${tileCoord.y}`;
+    }
     cacheCleaner() {
         const now = Date.now();
         for (const [tileKey, entry] of this._cachedTiles) {
             const t0 = entry.cacheTime0;
-            if (t0 !== undefined && now - t0 > this._cacheAliveMilliSeconds && !entry.tile.loading) {
-                entry.tile.dispose();
-                this._cachedTiles.delete(tileKey);
+            if (t0 === undefined || now - t0 <= this._cacheAliveMilliSeconds || entry.tile.loading) {
+                continue;
             }
+            entry.tile.dispose?.();
+            this._cachedTiles.delete(tileKey);
         }
     }
-    key(tileCoord) {
-        return `${tileCoord.z}/${tileCoord.x}/${tileCoord.y}`;
+    touchTile(tile) {
+        tile.touch?.();
+    }
+    getTileAgeScore(tile) {
+        const lastUsedAt = tile.lastUsedAt ?? 0;
+        const createdAt = tile.createdAt ?? lastUsedAt;
+        return Math.min(lastUsedAt || createdAt, createdAt);
     }
 }

package/lib-esm/model/earth/XYZTileRequestScheduler.d.ts

@@ -1,4 +1,4 @@
-import type { XYZRequestSchedulerDebugStats } from './types.js';
+import type { XYZRequestSchedulerDebugStats } from './XYZConfig.js';
 export declare class XYZTileRequestError extends Error {
     cooldownMs: number;
     retryable: boolean;

package/lib-esm/model/earth/XYZTileRequestScheduler.js

@@ -1,3 +1,15 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
 export class XYZTileRequestError extends Error {
     cooldownMs;
     retryable;
@@ -73,9 +85,8 @@ export class XYZTileRequestScheduler {
     pump() {
         while (this._activeCount < this._maxConcurrent && this._queue.length > 0) {
             const item = this._queue.shift();
-            if (!item) {
+            if (!item)
                 return;
-            }
             const hostCooldown = this.getHostCooldown(item.url);
             const now = Date.now();
             if (hostCooldown > now) {

package/lib-esm/model/earth/XYZTypes.d.ts

@@ -0,0 +1,24 @@
+export type XYZTileCoord = {
+    z: number;
+    x: number;
+    y: number;
+};
+export type XYZVisibleTileSelection = {
+    key: string;
+    currentZoom: number;
+    visibleTiles: XYZTileCoord[];
+    visibleTilesMap: Map<string, XYZTileCoord>;
+    ancestorsMap: Map<string, XYZTileCoord>;
+};
+export type XYZTileMesh = {
+    positions: Float32Array;
+    uvs: Float32Array;
+    indices: Uint16Array | Uint32Array;
+};
+export type XYZTileGpuMesh = {
+    positionBuffer: WebGLBuffer | null;
+    uvBuffer: WebGLBuffer | null;
+    indexBuffer: WebGLBuffer | null;
+    indexCount: number;
+    indexType: number;
+};

package/lib-esm/model/earth/XYZTypes.js

@@ -0,0 +1,13 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+export {};

package/lib-esm/model/earth/XYZVisibleTilesManager.d.ts

@@ -1,30 +1,19 @@
-import type { XYZTileCoord } from './types.js';
-import { XYZTileProvider } from './XYZTileProvider.js';
-import type { SkyEntityDrawInput } from '../AbstractSkyEntity.js';
-export type XYZTileSelection = {
-    key: string;
-    currentTiles: XYZTileCoord[];
-    fallbackTiles: XYZTileCoord[];
-    currentZoom: number;
-    coreTileCount: number;
-    coverageTileCount: number;
-};
+import { ReadonlyMat4 } from 'gl-matrix';
+import Camera from '../../Camera.js';
+import { AbstractSkyEntity } from '../AbstractSkyEntity.js';
+import type { XYZTileCoord, XYZVisibleTileSelection } from './XYZTypes.js';
 export declare class XYZVisibleTilesManager {
-    private _provider;
-    constructor(provider: XYZTileProvider);
-    selectTiles(input: SkyEntityDrawInput): XYZTileSelection;
-    private buildCoreVisibleTiles;
-    private buildCoverageTiles;
-    private collectCoverageSamples;
-    private interpolateFoVPolygon;
-    private getNeighborRing;
-    private isBoundaryTile;
-    private normalizeTile;
-    private normalizePhi;
-    private buildFallbackMap;
-    private buildFallbackSeedTiles;
-    private orderTilesByScreenRelevance;
-    private orderFallbackTiles;
-    private getCenterTileCoord;
+    private _ancestorsMap;
+    private _visibleTilesMap;
+    private _visibleTiles;
+    private _selection;
+    get ancestorsMap(): Map<string, XYZTileCoord>;
+    get visibleTiles(): XYZTileCoord[];
+    get visibleTilesMap(): Map<string, XYZTileCoord>;
+    get selection(): XYZVisibleTileSelection;
+    computeVisibleTiles(z: number, xyzModel: AbstractSkyEntity, webgl: WebGL2RenderingContext, camera: Camera, pMatrix: ReadonlyMat4, sampleCount?: number, padding?: number): XYZVisibleTileSelection;
+    private refreshAncestorsMap;
+    private buildTileMap;
+    private buildSelectionKey;
     private key;
 }

package/lib-esm/model/earth/XYZVisibleTilesManager.js

@@ -1,206 +1,75 @@
+/*
+ * AstroViewer
+ * Copyright (C) Fabrizio Giordano
+ * SPDX-License-Identifier: LicenseRef-AstroViewer-Dual-License
+ *
+ * This file is part of AstroViewer.
+ * AstroViewer is distributed under a dual-license model.
+ * Commercial use requires a separate commercial license.
+ * Non-commercial use is governed by LICENSE-NONCOMMERCIAL.md.
+ *
+ * See LICENSE.md, LICENSE-COMMERCIAL.md, and LICENSE-NONCOMMERCIAL.md for details.
+ */
+import XYZRayPickingUtils from '../../utils/XYZRayPickingUtils.js';
 export class XYZVisibleTilesManager {
-    _provider;
-    constructor(provider) {
-        this._provider = provider;
-    }
-    selectTiles(input) {
-        const currentZoom = this._provider.resolveZoom(input.fovDeg ?? 180);
-        const coreTiles = this.orderTilesByScreenRelevance(this.buildCoreVisibleTiles(currentZoom, input), currentZoom, input.centerSphericalDeg ?? null);
-        const coverageTiles = this.orderTilesByScreenRelevance(this.buildCoverageTiles(currentZoom, input, coreTiles), currentZoom, input.centerSphericalDeg ?? null);
-        const currentTiles = [...coreTiles, ...coverageTiles];
-        const fallbackSeedTiles = this.buildFallbackSeedTiles(coreTiles, currentZoom, input.centerSphericalDeg ?? null);
-        const fallbackTiles = this.orderFallbackTiles(Array.from(this.buildFallbackMap(fallbackSeedTiles, currentZoom).values()), currentZoom, input.centerSphericalDeg ?? null);
-        const key = `${currentZoom}:${currentTiles.map((tile) => `${tile.x}/${tile.y}`).join('|')}`;
-        return {
-            key,
-            currentTiles,
-            fallbackTiles,
-            currentZoom,
-            coreTileCount: coreTiles.length,
-            coverageTileCount: coverageTiles.length,
+    _ancestorsMap = new Map();
+    _visibleTilesMap = new Map();
+    _visibleTiles = [];
+    _selection = {
+        key: '0:',
+        currentZoom: 0,
+        visibleTiles: [],
+        visibleTilesMap: new Map(),
+        ancestorsMap: new Map(),
+    };
+    get ancestorsMap() {
+        return this._ancestorsMap;
+    }
+    get visibleTiles() {
+        return this._visibleTiles;
+    }
+    get visibleTilesMap() {
+        return this._visibleTilesMap;
+    }
+    get selection() {
+        return this._selection;
+    }
+    computeVisibleTiles(z, xyzModel, webgl, camera, pMatrix, sampleCount = 9, padding = 2) {
+        this._visibleTiles = XYZRayPickingUtils.getVisibleTilesFromViewport(z, xyzModel, webgl, camera, pMatrix, sampleCount, padding);
+        this._visibleTilesMap = this.buildTileMap(this._visibleTiles);
+        this.refreshAncestorsMap(this._visibleTiles);
+        this._selection = {
+            key: this.buildSelectionKey(z, this._visibleTiles),
+            currentZoom: z,
+            visibleTiles: this._visibleTiles,
+            visibleTilesMap: this._visibleTilesMap,
+            ancestorsMap: this._ancestorsMap,
         };
-    }
-    buildCoreVisibleTiles(currentZoom, input) {
-        const samples = this.collectCoverageSamples(input);
-        if (samples.length === 0) {
-            return this._provider.getVisibleTilesAtZoom(currentZoom, null, [], [], 0);
-        }
-        const tiles = [];
-        for (const sample of samples) {
-            tiles.push(this._provider.tileFromSpherical(currentZoom, sample));
-        }
-        return this._provider.deduplicateTiles(tiles);
-    }
-    buildCoverageTiles(currentZoom, input, coreTiles) {
-        if (coreTiles.length === 0) {
-            return [];
-        }
-        const ring = this.getNeighborRing(currentZoom, input.fovDeg ?? 180);
-        if (ring <= 0) {
-            return [];
-        }
-        const coreSet = new Set(coreTiles.map((tile) => this.key(tile)));
-        const coverageTiles = [];
-        for (const tile of coreTiles) {
-            if (!this.isBoundaryTile(tile, coreSet)) {
-                continue;
-            }
-            const neighbors = this._provider.getNeighborTiles(tile, ring);
-            for (const neighbor of neighbors) {
-                const neighborKey = this.key(neighbor);
-                if (coreSet.has(neighborKey)) {
-                    continue;
-                }
-                coverageTiles.push(neighbor);
-            }
-        }
-        return this._provider.deduplicateTiles(coverageTiles);
-    }
-    collectCoverageSamples(input) {
-        const samples = [];
-        if (input.centerSphericalDeg) {
-            samples.push(input.centerSphericalDeg);
-        }
-        for (const sample of input.viewportSphericalSamples ?? []) {
-            samples.push(sample);
-        }
-        const polygonSamples = this.interpolateFoVPolygon(input.fovPolygon ?? []);
-        for (const sample of polygonSamples) {
-            samples.push(sample);
-        }
-        return samples;
-    }
-    interpolateFoVPolygon(fovPolygon) {
-        if (fovPolygon.length === 0) {
-            return [];
-        }
-        const polygonSpherical = fovPolygon.map((point) => ({
-            phi: point.raDeg < 0 ? point.raDeg + 360 : point.raDeg,
-            theta: 90 - point.decDeg,
-        }));
-        const samples = [...polygonSpherical];
-        const segmentInterpolationCount = polygonSpherical.length >= 4 ? 3 : 1;
-        for (let i = 0; i < polygonSpherical.length; i++) {
-            const start = polygonSpherical[i];
-            const end = polygonSpherical[(i + 1) % polygonSpherical.length];
-            if (!start || !end)
-                continue;
-            const startPhi = this.normalizePhi(start.phi);
-            let endPhi = this.normalizePhi(end.phi);
-            if (Math.abs(endPhi - startPhi) > 180) {
-                endPhi += endPhi > startPhi ? -360 : 360;
-            }
-            for (let step = 1; step <= segmentInterpolationCount; step++) {
-                const t = step / (segmentInterpolationCount + 1);
-                const phi = this.normalizePhi(startPhi + (endPhi - startPhi) * t);
-                const theta = start.theta + (end.theta - start.theta) * t;
-                samples.push({ phi, theta });
-            }
-        }
-        return samples;
-    }
-    getNeighborRing(currentZoom, fovDeg) {
-        if (currentZoom >= 14 && fovDeg < 10) {
-            return 0;
-        }
-        return 1;
-    }
-    isBoundaryTile(tile, coreTileKeys) {
-        const directNeighbors = [
-            { z: tile.z, x: tile.x - 1, y: tile.y },
-            { z: tile.z, x: tile.x + 1, y: tile.y },
-            { z: tile.z, x: tile.x, y: tile.y - 1 },
-            { z: tile.z, x: tile.x, y: tile.y + 1 },
-        ];
-        return directNeighbors.some((neighbor) => !coreTileKeys.has(this.key(this.normalizeTile(neighbor))));
-    }
-    normalizeTile(tile) {
-        const dim = 2 ** tile.z;
-        return {
-            z: tile.z,
-            x: ((tile.x % dim) + dim) % dim,
-            y: Math.max(0, Math.min(dim - 1, tile.y)),
-        };
-    }
-    normalizePhi(phi) {
-        let value = phi;
-        while (value < 0)
-            value += 360;
-        while (value >= 360)
-            value -= 360;
-        return value;
-    }
-    buildFallbackMap(currentTiles, currentZoom) {
-        const fallbackMap = new Map();
-        const minFallbackZoom = Math.max(this._provider.minZoom, currentZoom - 2);
-        for (let z = currentZoom - 1; z >= minFallbackZoom; z--) {
-            const dz = currentZoom - z;
-            for (const tile of currentTiles) {
-                const fallback = {
+        return this._selection;
+    }
+    refreshAncestorsMap(visibleTiles) {
+        this._ancestorsMap.clear();
+        for (const tile of visibleTiles) {
+            for (let z = tile.z - 1; z >= 0; z--) {
+                const dz = tile.z - z;
+                const ancestor = {
                     z,
                     x: tile.x >> dz,
                     y: tile.y >> dz,
                 };
-                fallbackMap.set(`${fallback.z}/${fallback.x}/${fallback.y}`, fallback);
+                this._ancestorsMap.set(`${ancestor.z}/${ancestor.x}/${ancestor.y}`, ancestor);
             }
         }
-        return fallbackMap;
     }
-    buildFallbackSeedTiles(coreTiles, zoom, centerSphericalDeg) {
-        if (coreTiles.length === 0) {
-            return [];
-        }
-        const centerTile = this.getCenterTileCoord(zoom, centerSphericalDeg);
-        if (!centerTile) {
-            return coreTiles;
+    buildTileMap(tiles) {
+        const map = new Map();
+        for (const tile of tiles) {
+            map.set(this.key(tile), tile);
         }
-        const centerKey = this.key(centerTile);
-        if (coreTiles.some((tile) => this.key(tile) === centerKey)) {
-            return coreTiles;
-        }
-        return [...coreTiles, centerTile];
-    }
-    orderTilesByScreenRelevance(tiles, zoom, centerSphericalDeg) {
-        const centerTile = this.getCenterTileCoord(zoom, centerSphericalDeg);
-        if (!centerTile) {
-            return tiles;
-        }
-        return [...tiles].sort((a, b) => {
-            const distanceA = Math.abs(a.x - centerTile.x) + Math.abs(a.y - centerTile.y);
-            const distanceB = Math.abs(b.x - centerTile.x) + Math.abs(b.y - centerTile.y);
-            return distanceA - distanceB;
-        });
-    }
-    orderFallbackTiles(tiles, currentZoom, centerSphericalDeg) {
-        return [...tiles].sort((a, b) => {
-            if (b.z !== a.z) {
-                return b.z - a.z;
-            }
-            const centerTileA = this.getCenterTileCoord(a.z, centerSphericalDeg);
-            const centerTileB = this.getCenterTileCoord(b.z, centerSphericalDeg);
-            if (!centerTileA || !centerTileB) {
-                return 0;
-            }
-            const distanceA = Math.abs(a.x - centerTileA.x) + Math.abs(a.y - centerTileA.y);
-            const distanceB = Math.abs(b.x - centerTileB.x) + Math.abs(b.y - centerTileB.y);
-            return distanceA - distanceB || currentZoom - a.z - (currentZoom - b.z);
-        });
+        return map;
     }
-    getCenterTileCoord(zoom, centerSphericalDeg) {
-        if (!centerSphericalDeg) {
-            return null;
-        }
-        const lonDeg = centerSphericalDeg.phi > 180 ? centerSphericalDeg.phi - 360 : centerSphericalDeg.phi;
-        const latDeg = 90 - centerSphericalDeg.theta;
-        const dim = 2 ** zoom;
-        const x = Math.floor(((lonDeg + 180) / 360) * dim);
-        const latRad = (Math.max(-85.0511287798066, Math.min(85.0511287798066, latDeg)) * Math.PI) / 180;
-        const y = Math.floor(((1 - Math.asinh(Math.tan(latRad)) / Math.PI) / 2) * dim);
-        return {
-            z: zoom,
-            x: ((x % dim) + dim) % dim,
-            y: Math.max(0, Math.min(dim - 1, y)),
-        };
+    buildSelectionKey(z, tiles) {
+        return `${z}:${tiles.map((tile) => `${tile.x}/${tile.y}`).join('|')}`;
     }
     key(tile) {
         return `${tile.z}/${tile.x}/${tile.y}`;