astro-viewer 2.0.0 → 3.1.0

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

@@ -0,0 +1,172 @@
+/*
+ * 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;
+    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/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

@@ -0,0 +1,19 @@
+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 _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

@@ -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.
+ */
+import XYZRayPickingUtils from '../../utils/XYZRayPickingUtils.js';
+export class XYZVisibleTilesManager {
+    _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,
+        };
+        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,
+                };
+                this._ancestorsMap.set(`${ancestor.z}/${ancestor.x}/${ancestor.y}`, ancestor);
+            }
+        }
+    }
+    buildTileMap(tiles) {
+        const map = new Map();
+        for (const tile of tiles) {
+            map.set(this.key(tile), tile);
+        }
+        return map;
+    }
+    buildSelectionKey(z, tiles) {
+        return `${z}:${tiles.map((tile) => `${tile.x}/${tile.y}`).join('|')}`;
+    }
+    key(tile) {
+        return `${tile.z}/${tile.x}/${tile.y}`;
+    }
+}

package/lib-esm/model/footprints/Footprint.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.
+ */
 'use strict';
 /**
  * @author Fabrizio Giordano (Fab)

package/lib-esm/model/footprints/FootprintProps.js

@@ -1,6 +1,18 @@
+/*
+ * 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 {};
 // import {Metadata} from '../tap/TapMetadata.js';
 // import {TapMetadataList} from '../tap/TapMetadataList.js';
-export {};
 // export default class FootprintProps {
 //   // resolved columns
 //   pgSphereColumn?: Metadata;

package/lib-esm/model/footprints/FootprintSetGL.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.
+ */
 import { Footprint } from "./Footprint.js";
 import { colorHex2RGB } from "../../utils/Utils.js";
 import { FootprintShaderProgram } from "../../shader/FootprintShaderProgram.js";
@@ -126,7 +138,7 @@ export class FootprintSetGL {
             throw new Error("geomColumn or its index is undefined in footprintsetProps");
         }
         for (let j = 0; j < in_data.length; j++) {
-            if (in_data[j][0] !== null) {
+            if (in_data[j][geomDataIndex] !== null) {
                 const footprint = new Footprint(in_data[j][geomDataIndex], in_data[j]);
                 if (footprint._valid) {
                     this.addFootprint(footprint);

package/lib-esm/model/grid/EquatorialGrid.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.
+ */
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
 import { vec4, mat4 } from 'gl-matrix';
 import { fovHelper } from '../hips/FoVHelper.js';
@@ -19,7 +31,7 @@ export class EquatorialGrid extends AbstractSkyEntity {
     _vertexShader;
     _fragmentShader;
     defaultColor = '#41d421';
-    gridText = new GridTextHelper();
+    gridText = new GridTextHelper('equatorial');
     _attribLocations = {
         position: 0,
         selected: 1,
@@ -260,9 +272,10 @@ export class EquatorialGrid extends AbstractSkyEntity {
                         // perspective divide
                         clipspace[0] /= clipspace[3];
                         clipspace[1] /= clipspace[3];
-                        // clip->pixel
-                        const pixelX = (clipspace[0] * 0.5 + 0.5) * super.webgl.canvas.width;
-                        const pixelY = (clipspace[1] * -0.5 + 0.5) * super.webgl.canvas.height;
+                        // clip -> CSS pixels
+                        const canvasRect = super.webgl.canvas.getBoundingClientRect();
+                        const pixelX = canvasRect.left + (clipspace[0] * 0.5 + 0.5) * canvasRect.width;
+                        const pixelY = canvasRect.top + (clipspace[1] * -0.5 + 0.5) * canvasRect.height;
                         this.gridText.addEqDivSet(decDeg.toFixed(2), pixelX, pixelY, 'dec');
                         // gridTextHelper.addEqDivSet(decDeg.toFixed(2), pixelX, pixelY, 'dec');
                     }
@@ -283,8 +296,9 @@ export class EquatorialGrid extends AbstractSkyEntity {
                         vec4.transformMat4(clipspace, phiPoint, mvpMatrix);
                         clipspace[0] /= clipspace[3];
                         clipspace[1] /= clipspace[3];
-                        const pixelX = (clipspace[0] * 0.5 + 0.5) * super.webgl.canvas.width;
-                        const pixelY = (clipspace[1] * -0.5 + 0.5) * super.webgl.canvas.height;
+                        const canvasRect = super.webgl.canvas.getBoundingClientRect();
+                        const pixelX = canvasRect.left + (clipspace[0] * 0.5 + 0.5) * canvasRect.width;
+                        const pixelY = canvasRect.top + (clipspace[1] * -0.5 + 0.5) * canvasRect.height;
                         // gridTextHelper.addEqDivSet(raDeg.toFixed(2), pixelX, pixelY, 'ra');
                         this.gridText.addEqDivSet(raDeg.toFixed(2), pixelX, pixelY, 'ra');
                     }

package/lib-esm/model/grid/GridTextHelper.d.ts

@@ -1,25 +1,16 @@
-/**
- * @author Fabrizio Giordano (Fab)
- * @param in_radius - number
- * @param in_gl - GL context
- * @param in_position - array of double e.g. [0.0, 0.0, 0.0]
- */
+type GridLabelLayer = 'healpix' | 'equatorial' | 'lonlat';
 declare class GridTextHelper {
-    private _divEqContainerElement;
-    private _divHPXContainerElement;
-    private _divSets;
-    private _divSetNdx;
-    constructor();
+    private static layers;
+    private layer;
+    constructor(layer?: GridLabelLayer);
     initHtml(): void;
-    resetDivSets(): void;
-    /**
-     * Add / reuse a floating label for HPX coordinates
-     */
+    resetDivSets(layer?: GridLabelLayer): void;
     addHPXDivSet(msg: string, x: number, y: number): void;
-    /**
-     * Add / reuse a floating label for Equatorial coords
-     * @param type 'ra' or 'dec'
-     */
     addEqDivSet(msg: string, x: number, y: number, type: 'ra' | 'dec'): void;
+    addLonLatDivSet(msg: string, x: number, y: number, type: 'lon' | 'lat'): void;
+    private addLabel;
+    private classNameForKind;
+    private static getLayerState;
+    private static resolveContainer;
 }
 export default GridTextHelper;

package/lib-esm/model/grid/GridTextHelper.js

@@ -1,91 +1,94 @@
-/**
- * @author Fabrizio Giordano (Fab)
- * @param in_radius - number
- * @param in_gl - GL context
- * @param in_position - array of double e.g. [0.0, 0.0, 0.0]
+/*
+ * 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.
  */
 class GridTextHelper {
-    _divEqContainerElement;
-    _divHPXContainerElement;
-    _divSets;
-    _divSetNdx;
-    constructor() {
-        this._divEqContainerElement = document.querySelector('#gridcoords');
-        this._divHPXContainerElement = document.querySelector('#gridhpx');
-        this._divSetNdx = 0;
-        this._divSets = [];
+    static layers = new Map();
+    layer;
+    constructor(layer = 'equatorial') {
+        this.layer = layer;
+        GridTextHelper.getLayerState(layer);
     }
     initHtml() {
-        // Kept for API parity; nothing required here with current logic.
+        GridTextHelper.getLayerState(this.layer);
     }
-    resetDivSets() {
-        // Hide remaining divs and reset index
-        for (; this._divSetNdx < this._divSets.length; ++this._divSetNdx) {
-            this._divSets[this._divSetNdx].style.display = 'none';
+    resetDivSets(layer = this.layer) {
+        const state = GridTextHelper.getLayerState(layer);
+        for (; state.divSetNdx < state.divSets.length; ++state.divSetNdx) {
+            state.divSets[state.divSetNdx].style.display = 'none';
         }
-        this._divSetNdx = 0;
+        state.divSetNdx = 0;
     }
-    /**
-     * Add / reuse a floating label for HPX coordinates
-     */
     addHPXDivSet(msg, x, y) {
-        let divSet = this._divSets[this._divSetNdx++];
-        // Create on demand
+        this.addLabel('healpix', msg, x + 25, y, 'hpx');
+    }
+    addEqDivSet(msg, x, y, type) {
+        this.addLabel('equatorial', msg, type === 'ra' ? x + 25 : x, type === 'ra' ? y : y + 25, type);
+    }
+    addLonLatDivSet(msg, x, y, type) {
+        this.addLabel('lonlat', msg, type === 'lon' ? x + 25 : x, type === 'lon' ? y : y + 25, type);
+    }
+    addLabel(layer, msg, x, y, kind) {
+        const state = GridTextHelper.getLayerState(layer);
+        if (!state.container)
+            return;
+        let divSet = state.divSets[state.divSetNdx++];
         if (!divSet) {
             const div = document.createElement('div');
             const textNode = document.createTextNode('');
-            div.className = 'floating-div-ra'; // style like RA tags
             div.appendChild(textNode);
-            if (!this._divHPXContainerElement) {
-                this._divHPXContainerElement = document.querySelector('#gridhpx');
-            }
-            if (!this._divHPXContainerElement) {
-                // If container is still missing, abort gracefully
-                return;
-            }
-            this._divHPXContainerElement.appendChild(div);
+            state.container.appendChild(div);
             divSet = { div, textNode, style: div.style };
-            this._divSets.push(divSet);
+            state.divSets.push(divSet);
         }
-        // Show & position
+        divSet.div.className = this.classNameForKind(kind);
         divSet.style.display = 'block';
-        divSet.style.left = `${Math.floor(x + 25)}px`;
+        divSet.style.left = `${Math.floor(x)}px`;
         divSet.style.top = `${Math.floor(y)}px`;
         divSet.textNode.nodeValue = msg;
     }
-    /**
-     * Add / reuse a floating label for Equatorial coords
-     * @param type 'ra' or 'dec'
-     */
-    addEqDivSet(msg, x, y, type) {
-        let divSet = this._divSets[this._divSetNdx++];
-        if (!divSet) {
-            const div = document.createElement('div');
-            const textNode = document.createTextNode('');
-            div.className = type === 'ra' ? 'floating-div-ra' : 'floating-div-dec';
-            div.appendChild(textNode);
-            if (!this._divEqContainerElement) {
-                this._divEqContainerElement = document.querySelector('#gridcoords');
-            }
-            if (!this._divEqContainerElement) {
-                // If container is still missing, abort gracefully
-                return;
-            }
-            this._divEqContainerElement.appendChild(div);
-            divSet = { div, textNode, style: div.style };
-            this._divSets.push(divSet);
+    classNameForKind(kind) {
+        switch (kind) {
+            case 'dec':
+                return 'floating-div-dec';
+            case 'lat':
+                return 'floating-div-lat';
+            case 'lon':
+                return 'floating-div-lon';
+            case 'hpx':
+            case 'ra':
+            default:
+                return 'floating-div-ra';
         }
-        divSet.style.display = 'block';
-        if (type === 'ra') {
-            divSet.style.left = `${Math.floor(x + 25)}px`;
-            divSet.style.top = `${Math.floor(y)}px`;
+    }
+    static getLayerState(layer) {
+        const current = GridTextHelper.layers.get(layer);
+        if (current) {
+            if (!current.container)
+                current.container = GridTextHelper.resolveContainer(layer);
+            return current;
         }
-        else {
-            divSet.style.left = `${Math.floor(x)}px`;
-            divSet.style.top = `${Math.floor(y + 25)}px`;
+        const state = {
+            container: GridTextHelper.resolveContainer(layer),
+            divSets: [],
+            divSetNdx: 0,
+        };
+        GridTextHelper.layers.set(layer, state);
+        return state;
+    }
+    static resolveContainer(layer) {
+        if (layer === 'healpix') {
+            return document.querySelector('#gridhpx');
         }
-        divSet.textNode.nodeValue = msg;
+        return document.querySelector('#gridcoords');
     }
 }
-// export const gridTextHelper = new GridTextHelper();
 export default GridTextHelper;

package/lib-esm/model/grid/HealpixGrid.d.ts

@@ -1,6 +1,6 @@
 import { AbstractSkyEntity, SkyEntityDrawInput } from '../AbstractSkyEntity.js';
 import { ReadonlyMat4 } from 'gl-matrix';
-import { FoV } from '../FoV.js';
+import { SphereFoV } from '../SphereFoV.js';
 import { VisibleTilesManager } from '../hips/VisibleTilesManager.js';
 import Camera from '../../Camera.js';
 export declare class HealpixGrid extends AbstractSkyEntity {
@@ -28,13 +28,13 @@ export declare class HealpixGrid extends AbstractSkyEntity {
     private _visibleTilesManager;
     constructor(webgl: WebGL2RenderingContext);
     init(): void;
-    get fovObj(): FoV;
+    get fovObj(): SphereFoV;
     get RADIUS(): number;
     get INITIAL_POSITION(): [number, number, number];
     get INITIAL_PhiRad(): number;
     get INITIAL_ThetaRad(): number;
-    refreshFoV(camera: Camera, pMatrix: ReadonlyMat4): FoV;
-    getFoV(): FoV;
+    refreshFoV(camera: Camera, pMatrix: ReadonlyMat4): SphereFoV;
+    getFoV(): SphereFoV;
     getMinFoV(): number;
     private initShaders;
     initBuffers(pixels: number[], order: number): void;