astro-viewer 2.0.0 → 3.0.0

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

@@ -0,0 +1,187 @@
+import global from '../../Global.js';
+const MAX_MERCATOR_LAT = 85.0511287798066;
+export class XYZTileProvider {
+    _config;
+    constructor(config) {
+        this._config = config;
+    }
+    get config() {
+        return this._config;
+    }
+    get minZoom() {
+        return Math.max(0, Math.floor(this._config.minZoom ?? 0));
+    }
+    get maxZoom() {
+        return Math.max(this.minZoom, Math.floor(this._config.maxZoom ?? 6));
+    }
+    getInitialTiles() {
+        return this.getVisibleTilesAtZoom(1, null, [], [], 1);
+    }
+    getTileUrl(tile) {
+        if (this._config.urlResolver) {
+            return this._config.urlResolver(tile);
+        }
+        const effectiveY = this.getEffectiveTileY(tile);
+        const subdomain = this.getSubdomain(tile);
+        return this._config.urlTemplate
+            .replace(/\{z\}/g, String(tile.z))
+            .replace(/\{x\}/g, String(tile.x))
+            .replace(/\{y\}/g, String(effectiveY))
+            .replace(/\{s\}/g, subdomain);
+    }
+    resolveZoom(fovDeg) {
+        const safeFov = Math.max(0.01, Math.min(180, fovDeg));
+        const targetTileWidthDeg = Math.max(0.01, safeFov / 2);
+        const rawZoom = Math.ceil(Math.log2(360 / targetTileWidthDeg));
+        return this.clampZoom(rawZoom);
+    }
+    clampZoom(zoom) {
+        return Math.max(this.minZoom, Math.min(this.maxZoom, zoom));
+    }
+    getEffectiveTileY(tile) {
+        if (!this._config.flipY) {
+            return tile.y;
+        }
+        const dim = 2 ** tile.z;
+        return dim - 1 - tile.y;
+    }
+    getSubdomain(tile) {
+        const subdomains = this._config.subdomains ?? [];
+        if (subdomains.length === 0) {
+            return '';
+        }
+        const index = Math.abs(tile.x + tile.y + tile.z) % subdomains.length;
+        return subdomains[index] ?? '';
+    }
+    getVisibleTilesAtZoom(z, centerSphericalDeg, fovPolygon, viewportSphericalSamples, padding = 1) {
+        const dim = 2 ** z;
+        const center = this.resolveViewCenter(null, centerSphericalDeg);
+        const normalizedCenterLon = this.normalizeLonAround(center.lonDeg, center.lonDeg);
+        const polygonPoints = fovPolygon.length > 0
+            ? fovPolygon.map((point) => ({
+                lonDeg: this.normalizeLonAround(point.raDeg > 180 ? point.raDeg - 360 : point.raDeg, normalizedCenterLon),
+                latDeg: point.decDeg,
+            }))
+            : [center];
+        const samplePoints = viewportSphericalSamples.map((sample) => ({
+            lonDeg: this.normalizeLonAround(sample.phi > 180 ? sample.phi - 360 : sample.phi, normalizedCenterLon),
+            latDeg: 90 - sample.theta,
+        }));
+        const coveragePoints = [center, ...polygonPoints, ...samplePoints];
+        let minLon = normalizedCenterLon;
+        let maxLon = normalizedCenterLon;
+        let minLat = center.latDeg;
+        let maxLat = center.latDeg;
+        for (const point of coveragePoints) {
+            minLon = Math.min(minLon, point.lonDeg);
+            maxLon = Math.max(maxLon, point.lonDeg);
+            minLat = Math.min(minLat, point.latDeg);
+            maxLat = Math.max(maxLat, point.latDeg);
+        }
+        const adaptivePadding = Math.max(padding, Math.min(3, Math.max(1, Math.ceil(z / 3))));
+        const minX = Math.floor(((minLon + 180) / 360) * dim) - adaptivePadding;
+        const maxX = Math.floor(((maxLon + 180) / 360) * dim) + adaptivePadding;
+        const minY = Math.floor(this.latToTileY(maxLat, z)) - adaptivePadding;
+        const maxY = Math.floor(this.latToTileY(minLat, z)) + adaptivePadding;
+        const tiles = [];
+        for (let x = minX; x <= maxX; x++) {
+            for (let y = minY; y <= maxY; y++) {
+                tiles.push({
+                    z,
+                    x: this.wrapTileX(x, dim),
+                    y: this.clampTileY(y, dim),
+                });
+            }
+        }
+        for (const point of coveragePoints) {
+            const centerTileX = Math.floor(((point.lonDeg + 180) / 360) * dim);
+            const centerTileY = Math.floor(this.latToTileY(point.latDeg, z));
+            for (let dx = -adaptivePadding; dx <= adaptivePadding; dx++) {
+                for (let dy = -adaptivePadding; dy <= adaptivePadding; dy++) {
+                    tiles.push({
+                        z,
+                        x: this.wrapTileX(centerTileX + dx, dim),
+                        y: this.clampTileY(centerTileY + dy, dim),
+                    });
+                }
+            }
+        }
+        return this.deduplicateTiles(tiles);
+    }
+    tileFromSpherical(zoom, sphericalDeg) {
+        const lonDeg = sphericalDeg.phi > 180 ? sphericalDeg.phi - 360 : sphericalDeg.phi;
+        const latDeg = 90 - sphericalDeg.theta;
+        const dim = 2 ** zoom;
+        const x = Math.floor(((lonDeg + 180) / 360) * dim);
+        const y = Math.floor(this.latToTileY(latDeg, zoom));
+        return {
+            z: zoom,
+            x: this.wrapTileX(x, dim),
+            y: this.clampTileY(y, dim),
+        };
+    }
+    getNeighborTiles(tile, ring = 1) {
+        const dim = 2 ** tile.z;
+        const neighbors = [];
+        for (let dx = -ring; dx <= ring; dx++) {
+            for (let dy = -ring; dy <= ring; dy++) {
+                neighbors.push({
+                    z: tile.z,
+                    x: this.wrapTileX(tile.x + dx, dim),
+                    y: this.clampTileY(tile.y + dy, dim),
+                });
+            }
+        }
+        return this.deduplicateTiles(neighbors);
+    }
+    deduplicateTiles(tiles) {
+        const unique = new Map();
+        for (const tile of tiles) {
+            unique.set(`${tile.z}/${tile.x}/${tile.y}`, tile);
+        }
+        return Array.from(unique.values());
+    }
+    resolveViewCenter(camera, centerSphericalDeg) {
+        if (centerSphericalDeg) {
+            return {
+                lonDeg: centerSphericalDeg.phi > 180 ? centerSphericalDeg.phi - 360 : centerSphericalDeg.phi,
+                latDeg: 90 - centerSphericalDeg.theta,
+            };
+        }
+        if (!camera) {
+            return { lonDeg: 0, latDeg: 0 };
+        }
+        const [x, y, z] = camera.getCameraPosition();
+        const len = Math.hypot(x, y, z);
+        if (!Number.isFinite(len) || len === 0) {
+            return { lonDeg: 0, latDeg: 0 };
+        }
+        const scale = global.insideSphere ? 1 / len : -1 / len;
+        const vx = x * scale;
+        const vy = y * scale;
+        const vz = z * scale;
+        const lonDeg = (Math.atan2(vy, vx) * 180) / Math.PI;
+        const latDeg = (Math.asin(Math.max(-1, Math.min(1, vz))) * 180) / Math.PI;
+        return { lonDeg, latDeg };
+    }
+    latToTileY(latDeg, z) {
+        const lat = Math.max(-MAX_MERCATOR_LAT, Math.min(MAX_MERCATOR_LAT, latDeg));
+        const latRad = (lat * Math.PI) / 180;
+        const n = 2 ** z;
+        return ((1 - Math.asinh(Math.tan(latRad)) / Math.PI) / 2) * n;
+    }
+    wrapTileX(x, dim) {
+        return ((x % dim) + dim) % dim;
+    }
+    normalizeLonAround(lonDeg, referenceLonDeg) {
+        let lon = lonDeg;
+        while (lon - referenceLonDeg > 180)
+            lon -= 360;
+        while (lon - referenceLonDeg < -180)
+            lon += 360;
+        return lon;
+    }
+    clampTileY(y, dim) {
+        return Math.max(0, Math.min(dim - 1, y));
+    }
+}

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

@@ -0,0 +1,25 @@
+import type { XYZRequestSchedulerDebugStats } from './types.js';
+export declare class XYZTileRequestError extends Error {
+    cooldownMs: number;
+    retryable: boolean;
+    constructor(message: string, cooldownMs: number, retryable?: boolean);
+}
+export declare class XYZTileRequestScheduler {
+    private _maxConcurrent;
+    private _activeCount;
+    private _queue;
+    private _inflight;
+    private _hostBackoff;
+    private _sequence;
+    constructor(maxConcurrent?: number);
+    setMaxConcurrent(maxConcurrent: number): void;
+    getMaxConcurrent(): number;
+    getDebugStats(): XYZRequestSchedulerDebugStats;
+    load(url: string, priority?: number): Promise<Blob>;
+    private pump;
+    private fetchBlob;
+    private getHostCooldown;
+    private registerSuccess;
+    private registerFailure;
+}
+export declare const xyzTileRequestScheduler: XYZTileRequestScheduler;

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

@@ -0,0 +1,161 @@
+export class XYZTileRequestError extends Error {
+    cooldownMs;
+    retryable;
+    constructor(message, cooldownMs, retryable = true) {
+        super(message);
+        this.name = 'XYZTileRequestError';
+        this.cooldownMs = cooldownMs;
+        this.retryable = retryable;
+    }
+}
+export class XYZTileRequestScheduler {
+    _maxConcurrent;
+    _activeCount = 0;
+    _queue = [];
+    _inflight = new Map();
+    _hostBackoff = new Map();
+    _sequence = 0;
+    constructor(maxConcurrent = 4) {
+        this._maxConcurrent = maxConcurrent;
+    }
+    setMaxConcurrent(maxConcurrent) {
+        this._maxConcurrent = Math.max(1, Math.floor(maxConcurrent));
+        this.pump();
+    }
+    getMaxConcurrent() {
+        return this._maxConcurrent;
+    }
+    getDebugStats() {
+        const now = Date.now();
+        const hostsInBackoff = Array.from(this._hostBackoff.entries())
+            .map(([host, state]) => ({
+            host,
+            cooldownMs: Math.max(0, state.cooldownUntil - now),
+            consecutiveFailures: state.consecutiveFailures,
+        }))
+            .filter((entry) => entry.cooldownMs > 0 || entry.consecutiveFailures > 0)
+            .sort((a, b) => b.cooldownMs - a.cooldownMs);
+        return {
+            activeRequests: this._activeCount,
+            queuedRequests: this._queue.length,
+            inflightRequests: this._inflight.size,
+            maxConcurrentRequests: this._maxConcurrent,
+            highestQueuedPriority: this._queue[0]?.priority ?? null,
+            hostsInBackoff,
+        };
+    }
+    load(url, priority = 0) {
+        const inflight = this._inflight.get(url);
+        if (inflight) {
+            return inflight;
+        }
+        const hostCooldown = this.getHostCooldown(url);
+        const now = Date.now();
+        if (hostCooldown > now) {
+            return Promise.reject(new XYZTileRequestError(`Cooldown active for ${new URL(url).host}`, hostCooldown - now));
+        }
+        const promise = new Promise((resolve, reject) => {
+            this._queue.push({
+                url,
+                resolve,
+                reject,
+                priority,
+                sequence: this._sequence++,
+            });
+            this._queue.sort((a, b) => b.priority - a.priority || a.sequence - b.sequence);
+            this.pump();
+        }).finally(() => {
+            this._inflight.delete(url);
+        });
+        this._inflight.set(url, promise);
+        return promise;
+    }
+    pump() {
+        while (this._activeCount < this._maxConcurrent && this._queue.length > 0) {
+            const item = this._queue.shift();
+            if (!item) {
+                return;
+            }
+            const hostCooldown = this.getHostCooldown(item.url);
+            const now = Date.now();
+            if (hostCooldown > now) {
+                item.reject(new XYZTileRequestError(`Cooldown active for ${new URL(item.url).host}`, hostCooldown - now));
+                continue;
+            }
+            this._activeCount += 1;
+            this.fetchBlob(item)
+                .then(item.resolve)
+                .catch(item.reject)
+                .finally(() => {
+                this._activeCount -= 1;
+                this.pump();
+            });
+        }
+    }
+    async fetchBlob(item) {
+        try {
+            const response = await fetch(item.url, {
+                mode: 'cors',
+                cache: 'force-cache',
+            });
+            if (!response.ok) {
+                const isTransient = response.status === 429 || response.status >= 500;
+                const cooldownMs = this.registerFailure(item.url, isTransient);
+                throw new XYZTileRequestError(`HTTP ${response.status} loading ${item.url}`, isTransient ? cooldownMs : 5 * 60 * 1000, isTransient);
+            }
+            this.registerSuccess(item.url);
+            return await response.blob();
+        }
+        catch (error) {
+            if (error instanceof XYZTileRequestError) {
+                throw error;
+            }
+            const cooldownMs = this.registerFailure(item.url, false);
+            throw new XYZTileRequestError(`Network/CORS failure loading ${item.url}`, cooldownMs, true);
+        }
+    }
+    getHostCooldown(url) {
+        try {
+            return this._hostBackoff.get(new URL(url).host)?.cooldownUntil ?? 0;
+        }
+        catch {
+            return 0;
+        }
+    }
+    registerSuccess(url) {
+        try {
+            const host = new URL(url).host;
+            this._hostBackoff.set(host, {
+                cooldownUntil: 0,
+                consecutiveFailures: 0,
+            });
+        }
+        catch {
+            // no-op
+        }
+    }
+    registerFailure(url, isRateLimited) {
+        if (!isRateLimited) {
+            return 0;
+        }
+        try {
+            const host = new URL(url).host;
+            const previous = this._hostBackoff.get(host) ?? {
+                cooldownUntil: 0,
+                consecutiveFailures: 0,
+            };
+            const consecutiveFailures = previous.consecutiveFailures + 1;
+            const baseDelayMs = 4000;
+            const cooldownMs = Math.min(120000, baseDelayMs * (2 ** Math.min(consecutiveFailures - 1, 5)));
+            this._hostBackoff.set(host, {
+                cooldownUntil: Date.now() + cooldownMs,
+                consecutiveFailures,
+            });
+            return cooldownMs;
+        }
+        catch {
+            return 30000;
+        }
+    }
+}
+export const xyzTileRequestScheduler = new XYZTileRequestScheduler();

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

@@ -0,0 +1,30 @@
+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;
+};
+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 key;
+}

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

@@ -0,0 +1,208 @@
+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,
+        };
+    }
+    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 = {
+                    z,
+                    x: tile.x >> dz,
+                    y: tile.y >> dz,
+                };
+                fallbackMap.set(`${fallback.z}/${fallback.x}/${fallback.y}`, fallback);
+            }
+        }
+        return fallbackMap;
+    }
+    buildFallbackSeedTiles(coreTiles, zoom, centerSphericalDeg) {
+        if (coreTiles.length === 0) {
+            return [];
+        }
+        const centerTile = this.getCenterTileCoord(zoom, centerSphericalDeg);
+        if (!centerTile) {
+            return coreTiles;
+        }
+        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);
+        });
+    }
+    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)),
+        };
+    }
+    key(tile) {
+        return `${tile.z}/${tile.x}/${tile.y}`;
+    }
+}

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

@@ -0,0 +1,87 @@
+export type XYZLayerConfig = {
+    urlTemplate: string;
+    minZoom?: number;
+    maxZoom?: number;
+    segmentsPerSide?: number;
+    tileSize?: number;
+    maxCachedTiles?: number;
+    interactionDebounceMs?: number;
+    subdomains?: string[];
+    attribution?: string;
+    flipY?: boolean;
+    urlResolver?: (tile: XYZTileCoord) => string;
+};
+export type XYZLayerDebugStats = {
+    cacheSize: number;
+    visibleTileCount: number;
+    currentTileCount: number;
+    fallbackTileCount: number;
+    coreTileCount: number;
+    coverageTileCount: number;
+    readyTileCount: number;
+    loadingTileCount: number;
+    coolingDownTileCount: number;
+    currentZoom: number | null;
+    tileSelectionKey: string | null;
+    isSettling: boolean;
+    coarseTileCount: number;
+    hasPendingSelection: boolean;
+    pendingSelectionKey: string | null;
+};
+export type XYZRequestBackoffDebugEntry = {
+    host: string;
+    cooldownMs: number;
+    consecutiveFailures: number;
+};
+export type XYZRequestSchedulerDebugStats = {
+    activeRequests: number;
+    queuedRequests: number;
+    inflightRequests: number;
+    maxConcurrentRequests: number;
+    highestQueuedPriority: number | null;
+    hostsInBackoff: XYZRequestBackoffDebugEntry[];
+};
+export type XYZDebugStats = {
+    activeBaseLayer: 'hips' | 'xyz' | null;
+    layer: XYZLayerDebugStats | null;
+    requests: XYZRequestSchedulerDebugStats;
+};
+export type XYZTileCoord = {
+    z: number;
+    x: number;
+    y: number;
+};
+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;
+};
+export type WMTSRequestEncoding = 'kvp' | 'rest';
+export type WMTSLayerConfig = {
+    baseUrl: string;
+    layer: string;
+    tileMatrixSet: string;
+    style?: string;
+    time?: string;
+    format?: string;
+    requestEncoding?: WMTSRequestEncoding;
+    version?: string;
+    dimensions?: Record<string, string>;
+    matrixLabels?: string[];
+    urlTemplate?: string;
+    minZoom?: number;
+    maxZoom?: number;
+    segmentsPerSide?: number;
+    tileSize?: number;
+    maxCachedTiles?: number;
+    subdomains?: string[];
+    attribution?: string;
+    flipY?: boolean;
+};