astro-viewer 2.0.0 → 3.1.0

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

@@ -0,0 +1,77 @@
+/*
+ * 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 XYZMapDescriptor {
+    _name;
+    _url;
+    _urlResolver;
+    _minZoom;
+    _maxZoom;
+    _segmentsPerSide;
+    _tileSize;
+    _maxCachedTiles;
+    _interactionDebounceMs;
+    _subdomains;
+    _attribution;
+    _flipY;
+    _maxConcurrentLoads;
+    constructor(name, url, minZoom = 0, maxZoom = 8, segmentsPerSide = 16, maxCachedTiles = 384, maxConcurrentLoads = 8, urlResolver) {
+        this._name = name;
+        this._url = url;
+        this._urlResolver = urlResolver;
+        this._minZoom = minZoom;
+        this._maxZoom = maxZoom;
+        this._segmentsPerSide = segmentsPerSide;
+        this._maxCachedTiles = maxCachedTiles;
+        this._interactionDebounceMs = 100;
+        this._subdomains = ['a', 'b', 'c'];
+        this._attribution = '';
+        this._flipY = false;
+        this._maxConcurrentLoads = maxConcurrentLoads;
+    }
+    get url() {
+        return this._url;
+    }
+    get urlResolver() {
+        return this._urlResolver;
+    }
+    get name() {
+        return this._name;
+    }
+    get minZoom() {
+        return this._minZoom;
+    }
+    get maxZoom() {
+        return this._maxZoom;
+    }
+    get segmentsPerSide() {
+        return this._segmentsPerSide;
+    }
+    get maxCachedTiles() {
+        return this._maxCachedTiles;
+    }
+    get interactionDebounceMs() {
+        return this._interactionDebounceMs;
+    }
+    get subdomains() {
+        return this._subdomains;
+    }
+    get attribution() {
+        return this._attribution;
+    }
+    get flipY() {
+        return this._flipY;
+    }
+    get maxConcurrentLoads() {
+        return this._maxConcurrentLoads;
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { XYZTileCoord, XYZTileGpuMesh, XYZTileMesh } from './XYZTypes.js';
+export declare class XYZMeshBuilder {
+    buildTileMesh(tile: XYZTileCoord, segmentsPerSide?: number): XYZTileMesh;
+    buildAncestorMesh(targetTile: XYZTileCoord, ancestorTile: XYZTileCoord, segmentsPerSide?: number): XYZTileMesh;
+    uploadMesh(mesh: XYZTileMesh, webgl: WebGL2RenderingContext): XYZTileGpuMesh;
+}

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

@@ -0,0 +1,108 @@
+/*
+ * 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 { sphericalToCartesian } from '../../utils/Utils.js';
+const MAX_MERCATOR_LAT = 85.0511287798066;
+function mercatorYToLatDeg(yNormalized) {
+    const mercator = Math.PI * (1 - 2 * yNormalized);
+    return (Math.atan(Math.sinh(mercator)) * 180) / Math.PI;
+}
+function wrapLonToPhi(lonDeg) {
+    return lonDeg < 0 ? lonDeg + 360 : lonDeg;
+}
+export class XYZMeshBuilder {
+    buildTileMesh(tile, segmentsPerSide = 16) {
+        const segments = Math.max(1, Math.floor(segmentsPerSide));
+        const gridSize = segments + 1;
+        const vertexCount = gridSize * gridSize;
+        const positions = new Float32Array(vertexCount * 3);
+        const uvs = new Float32Array(vertexCount * 2);
+        const tileCount = 2 ** tile.z;
+        let p = 0;
+        let uv = 0;
+        for (let row = 0; row <= segments; row++) {
+            const v = row / segments;
+            const yNormalized = (tile.y + v) / tileCount;
+            const latDeg = Math.max(-MAX_MERCATOR_LAT, Math.min(MAX_MERCATOR_LAT, mercatorYToLatDeg(yNormalized)));
+            const thetaDeg = 90 - latDeg;
+            for (let col = 0; col <= segments; col++) {
+                const u = col / segments;
+                const xNormalized = (tile.x + u) / tileCount;
+                const lonDeg = xNormalized * 360 - 180;
+                const phiDeg = wrapLonToPhi(lonDeg);
+                const [x, y, z] = sphericalToCartesian(phiDeg, thetaDeg, 1);
+                positions[p++] = x;
+                positions[p++] = y;
+                positions[p++] = z;
+                uvs[uv++] = u;
+                uvs[uv++] = 1 - v;
+            }
+        }
+        const rawIndices = new Uint32Array(segments * segments * 2 * 3);
+        let i = 0;
+        for (let row = 0; row < segments; row++) {
+            for (let col = 0; col < segments; col++) {
+                const topLeft = row * gridSize + col;
+                const topRight = topLeft + 1;
+                const bottomLeft = topLeft + gridSize;
+                const bottomRight = bottomLeft + 1;
+                rawIndices[i++] = topLeft;
+                rawIndices[i++] = bottomLeft;
+                rawIndices[i++] = topRight;
+                rawIndices[i++] = topRight;
+                rawIndices[i++] = bottomLeft;
+                rawIndices[i++] = bottomRight;
+            }
+        }
+        const indices = rawIndices.length > 65535 ? rawIndices : new Uint16Array(rawIndices);
+        return { positions, uvs, indices };
+    }
+    buildAncestorMesh(targetTile, ancestorTile, segmentsPerSide = 16) {
+        const baseMesh = this.buildTileMesh(targetTile, segmentsPerSide);
+        const dz = targetTile.z - ancestorTile.z;
+        const scale = 2 ** dz;
+        const subTileX = targetTile.x - (ancestorTile.x << dz);
+        const subTileY = targetTile.y - (ancestorTile.y << dz);
+        const uvs = new Float32Array(baseMesh.uvs.length);
+        for (let i = 0; i < baseMesh.uvs.length; i += 2) {
+            const u = baseMesh.uvs[i] ?? 0;
+            const baseV = baseMesh.uvs[i + 1] ?? 0;
+            const v = 1 - baseV;
+            uvs[i] = (subTileX + u) / scale;
+            uvs[i + 1] = 1 - (subTileY + v) / scale;
+        }
+        return {
+            positions: baseMesh.positions,
+            uvs,
+            indices: baseMesh.indices,
+        };
+    }
+    uploadMesh(mesh, webgl) {
+        const positionBuffer = webgl.createBuffer();
+        const uvBuffer = webgl.createBuffer();
+        const indexBuffer = webgl.createBuffer();
+        const indexType = mesh.indices instanceof Uint32Array ? webgl.UNSIGNED_INT : webgl.UNSIGNED_SHORT;
+        webgl.bindBuffer(webgl.ARRAY_BUFFER, positionBuffer);
+        webgl.bufferData(webgl.ARRAY_BUFFER, mesh.positions, webgl.STATIC_DRAW);
+        webgl.bindBuffer(webgl.ARRAY_BUFFER, uvBuffer);
+        webgl.bufferData(webgl.ARRAY_BUFFER, mesh.uvs, webgl.STATIC_DRAW);
+        webgl.bindBuffer(webgl.ELEMENT_ARRAY_BUFFER, indexBuffer);
+        webgl.bufferData(webgl.ELEMENT_ARRAY_BUFFER, mesh.indices, webgl.STATIC_DRAW);
+        return {
+            positionBuffer,
+            uvBuffer,
+            indexBuffer,
+            indexCount: mesh.indices.length,
+            indexType,
+        };
+    }
+}

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

@@ -0,0 +1,38 @@
+import { XYZShaderProgram } from '../../shader/XYZShaderProgram.js';
+import type { XYZBufferedTile } from './XYZTileBuffer.js';
+import { XYZMeshBuilder } from './XYZMeshBuilder.js';
+import type { XYZTileCoord, XYZTileGpuMesh } from './XYZTypes.js';
+type Mat4 = Float32Array;
+export declare class XYZTile implements XYZBufferedTile {
+    private _coord;
+    private _url;
+    private _webgl;
+    private _shaderProgram;
+    private _meshBuilder;
+    private _gpuMesh;
+    private _texture;
+    private _image?;
+    private _ready;
+    private _loading;
+    private _aborted;
+    private _failedUntil;
+    private _lastUsedAt;
+    private _createdAt;
+    constructor(coord: XYZTileCoord, url: string, webgl: WebGL2RenderingContext, shaderProgram: XYZShaderProgram, meshBuilder?: XYZMeshBuilder, segmentsPerSide?: number);
+    get coord(): XYZTileCoord;
+    get ready(): boolean;
+    get loading(): boolean;
+    get failedUntil(): number;
+    get lastUsedAt(): number;
+    get createdAt(): number;
+    touch(): void;
+    private initImage;
+    private imageLoaded;
+    private textureLoaded;
+    draw(pMatrix: Mat4, vMatrix: Mat4, mMatrix: Mat4, colorMapIdx: number): boolean;
+    drawRemapped(mesh: XYZTileGpuMesh, pMatrix: Mat4, vMatrix: Mat4, mMatrix: Mat4, colorMapIdx: number): boolean;
+    dispose(): void;
+    private drawWithGpuMesh;
+    private get key();
+}
+export {};

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

@@ -0,0 +1,167 @@
+/*
+ * 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 { XYZMeshBuilder } from './XYZMeshBuilder.js';
+export class XYZTile {
+    _coord;
+    _url;
+    _webgl;
+    _shaderProgram;
+    _meshBuilder;
+    _gpuMesh;
+    _texture = null;
+    _image;
+    _ready = false;
+    _loading = false;
+    _aborted = false;
+    _failedUntil = 0;
+    _lastUsedAt = 0;
+    _createdAt = Date.now();
+    constructor(coord, url, webgl, shaderProgram, meshBuilder = new XYZMeshBuilder(), segmentsPerSide = 16) {
+        this._coord = coord;
+        this._url = url;
+        this._webgl = webgl;
+        this._shaderProgram = shaderProgram;
+        this._meshBuilder = meshBuilder;
+        const mesh = this._meshBuilder.buildTileMesh(coord, segmentsPerSide);
+        this._gpuMesh = this._meshBuilder.uploadMesh(mesh, this._webgl);
+        this.initImage();
+    }
+    get coord() {
+        return this._coord;
+    }
+    get ready() {
+        return this._ready;
+    }
+    get loading() {
+        return this._loading;
+    }
+    get failedUntil() {
+        return this._failedUntil;
+    }
+    get lastUsedAt() {
+        return this._lastUsedAt;
+    }
+    get createdAt() {
+        return this._createdAt;
+    }
+    touch() {
+        this._lastUsedAt = Date.now();
+    }
+    initImage() {
+        if (this._loading || this._ready || this._aborted) {
+            return;
+        }
+        const now = Date.now();
+        if (this._failedUntil > now) {
+            return;
+        }
+        this._loading = true;
+        const image = new Image();
+        this._image = image;
+        image.crossOrigin = 'anonymous';
+        image.onload = () => this.imageLoaded();
+        image.onerror = () => {
+            this._ready = false;
+            this._loading = false;
+            this._failedUntil = Date.now() + 30_000;
+        };
+        image.src = this._url;
+    }
+    imageLoaded() {
+        if (!this._image || this._aborted) {
+            return;
+        }
+        this.textureLoaded(this._image);
+        this._loading = false;
+        this._failedUntil = 0;
+        this._ready = true;
+    }
+    textureLoaded(image) {
+        const gl = this._webgl;
+        this._shaderProgram.enableProgram();
+        const texture = gl.createTexture();
+        if (!texture) {
+            throw new Error(`Could not create XYZ texture for ${this.key}`);
+        }
+        this._texture = texture;
+        gl.activeTexture(gl.TEXTURE0);
+        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, true);
+        gl.bindTexture(gl.TEXTURE_2D, texture);
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+    }
+    draw(pMatrix, vMatrix, mMatrix, colorMapIdx) {
+        this.touch();
+        if (!this._ready || !this._texture || this._aborted) {
+            return false;
+        }
+        this.drawWithGpuMesh(this._gpuMesh, pMatrix, vMatrix, mMatrix, colorMapIdx);
+        return true;
+    }
+    drawRemapped(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx) {
+        this.touch();
+        if (!this._ready || !this._texture || this._aborted) {
+            return false;
+        }
+        this.drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx);
+        return true;
+    }
+    dispose() {
+        const gl = this._webgl;
+        if (this._texture) {
+            gl.deleteTexture(this._texture);
+            this._texture = null;
+        }
+        if (this._gpuMesh.positionBuffer) {
+            gl.deleteBuffer(this._gpuMesh.positionBuffer);
+            this._gpuMesh.positionBuffer = null;
+        }
+        if (this._gpuMesh.uvBuffer) {
+            gl.deleteBuffer(this._gpuMesh.uvBuffer);
+            this._gpuMesh.uvBuffer = null;
+        }
+        if (this._gpuMesh.indexBuffer) {
+            gl.deleteBuffer(this._gpuMesh.indexBuffer);
+            this._gpuMesh.indexBuffer = null;
+        }
+        this._image = undefined;
+        this._ready = false;
+        this._loading = false;
+        this._aborted = true;
+    }
+    drawWithGpuMesh(mesh, pMatrix, vMatrix, mMatrix, colorMapIdx) {
+        if (!this._texture) {
+            return;
+        }
+        const gl = this._webgl;
+        this._shaderProgram.enableShaders(pMatrix, vMatrix, mMatrix, colorMapIdx);
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.positionBuffer);
+        gl.vertexAttribPointer(this._shaderProgram.locations.vertexPositionAttribute, 3, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
+        gl.bindBuffer(gl.ARRAY_BUFFER, mesh.uvBuffer);
+        gl.vertexAttribPointer(this._shaderProgram.locations.textureCoordAttribute, 2, gl.FLOAT, false, 0, 0);
+        gl.enableVertexAttribArray(this._shaderProgram.locations.textureCoordAttribute);
+        gl.activeTexture(gl.TEXTURE0);
+        gl.bindTexture(gl.TEXTURE_2D, this._texture);
+        gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, mesh.indexBuffer);
+        gl.drawElements(gl.TRIANGLES, mesh.indexCount, mesh.indexType, 0);
+        gl.disableVertexAttribArray(this._shaderProgram.locations.vertexPositionAttribute);
+        gl.disableVertexAttribArray(this._shaderProgram.locations.textureCoordAttribute);
+    }
+    get key() {
+        return `${this._coord.z}/${this._coord.x}/${this._coord.y}`;
+    }
+}

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

@@ -0,0 +1,37 @@
+import type { XYZTileCoord } from './XYZTypes.js';
+export type XYZBufferedTile = {
+    coord: XYZTileCoord;
+    loading?: boolean;
+    lastUsedAt?: number;
+    createdAt?: number;
+    touch?: () => void;
+    dispose?: () => void;
+};
+export type XYZTileBufferEntry<TTile extends XYZBufferedTile = XYZBufferedTile> = {
+    tile: TTile;
+    cacheTime0?: number;
+};
+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;
+    constructor(minutesToLiveInCache?: number);
+    get activeTiles(): Map<string, XYZTileBufferEntry<TTile>>;
+    get cachedTiles(): Map<string, XYZTileBufferEntry<TTile>>;
+    get size(): number;
+    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 touchTile;
+    private getTileAgeScore;
+}

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

@@ -0,0 +1,139 @@
+/*
+ * 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;
+    constructor(minutesToLiveInCache = 1) {
+        this._cacheAliveMilliSeconds = minutesToLiveInCache * 60 * 1000;
+        if (typeof window !== 'undefined') {
+            this._cleanerId = window.setInterval(() => {
+                this.cacheCleaner();
+            }, 10_000);
+        }
+    }
+    get activeTiles() {
+        return this._tiles;
+    }
+    get cachedTiles() {
+        return this._cachedTiles;
+    }
+    get size() {
+        return this._tiles.size + this._cachedTiles.size;
+    }
+    ensureTiles(visibleTiles, tileFactory) {
+        const visibleTileKeys = [];
+        for (const tileCoord of visibleTiles) {
+            const tile = this.getTile(tileCoord, tileFactory);
+            this.touchTile(tile);
+            visibleTileKeys.push(this.key(tileCoord));
+        }
+        this.syncVisibleTiles(visibleTileKeys);
+        return visibleTileKeys;
+    }
+    getTile(tileCoord, tileFactory) {
+        const tileKey = this.key(tileCoord);
+        if (this._tiles.has(tileKey)) {
+            return this._tiles.get(tileKey).tile;
+        }
+        if (this._cachedTiles.has(tileKey)) {
+            const entry = this._cachedTiles.get(tileKey);
+            entry.cacheTime0 = undefined;
+            this._tiles.set(tileKey, entry);
+            this._cachedTiles.delete(tileKey);
+            return entry.tile;
+        }
+        const tile = tileFactory(tileCoord);
+        this._tiles.set(tileKey, { tile });
+        return tile;
+    }
+    getActiveTile(tileKey) {
+        return this._tiles.get(tileKey)?.tile ?? null;
+    }
+    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)) {
+                this.touchTile(entry.tile);
+                continue;
+            }
+            entry.cacheTime0 = Date.now();
+            this._cachedTiles.set(tileKey, entry);
+            this._tiles.delete(tileKey);
+        }
+    }
+    evictCached(maxCachedTiles) {
+        if (this.size <= maxCachedTiles) {
+            return;
+        }
+        const candidates = Array.from(this._cachedTiles.entries()).sort((a, b) => {
+            return this.getTileAgeScore(a[1].tile) - this.getTileAgeScore(b[1].tile);
+        });
+        for (const [tileKey, entry] of candidates) {
+            if (this.size <= maxCachedTiles) {
+                break;
+            }
+            if (entry.tile.loading) {
+                continue;
+            }
+            entry.tile.dispose?.();
+            this._cachedTiles.delete(tileKey);
+        }
+    }
+    dispose() {
+        if (this._cleanerId !== undefined && typeof window !== 'undefined') {
+            window.clearInterval(this._cleanerId);
+            this._cleanerId = undefined;
+        }
+        for (const entry of this._tiles.values()) {
+            entry.tile.dispose?.();
+        }
+        for (const entry of this._cachedTiles.values()) {
+            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) {
+                continue;
+            }
+            entry.tile.dispose?.();
+            this._cachedTiles.delete(tileKey);
+        }
+    }
+    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

@@ -0,0 +1,25 @@
+import type { XYZRequestSchedulerDebugStats } from './XYZConfig.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;