isard 1.1.0 → 1.2.0

package/dist/map.d.ts

@@ -2,109 +2,78 @@
  * The map: canvas, camera, layers, events, overlays, credits and the frame loop. Frames are drawn on demand only: an
  * idle map costs nothing. Hover events are coalesced to one per frame, so the values computed for a mouse position are
  * drawn in the same frame. The engine's loading is in engine-loader.ts, its settings from the options in settings.ts,
- * the camera animations in animation.ts.
+ * the camera animations in animation.ts; the parts of the map with a state of their own (the drawing order of the
+ * layers, the overlays and controls, the frame loop, the hover picking, the workers…) in map/.
  */
 import { type PmtilesOptions, VectorTiles, type VectorTilesOptions } from './basemap/vectortiles.ts';
 import { ExtrusionLayer, type ExtrusionOptions } from './layers/extrusions.ts';
 import { CircleLayer, type CircleOptions, FillLayer, type FillOptions, LineLayer, type LineOptions } from './layers/features.ts';
-import { type ImageOptions, type Pixels } from './layers/icons.ts';
+import type { ImageOptions, Pixels } from './layers/icons.ts';
 import { CustomLayer, type CustomLayerInterface, GroundLayer, type GroundOptions, type Layer, ModelLayer, type ModelOptions, NetworkLayer, RasterLayer, Tiles3dLayer } from './layers/layers.ts';
 import { type PanoramaOptions, type Panoramas } from './layers/panoramas.ts';
 import { PointCloudLayer, type PointCloudOptions } from './layers/pointclouds.ts';
 import { SymbolLayer, type SymbolOptions } from './layers/symbols.ts';
+import { type HoverPicking } from './map/hover-pick.ts';
+import { type LayerSpec } from './map/layer-spec.ts';
 import type { AnimationOptions, AtmosphereOptions, Basemap, FeatureHit, FirstPersonView, FlyToOptions, GeoMapOptions, LoadingMode, LonLat, MapEvents, NetworkOptions, Point, Projection, RasterOptions, SwipeOptions, TerrainModel, TerrainOptions, Tiles3dOptions, ViewshedOptions } from './types.ts';
 import { type Control, type ControlPosition } from './ui/controls.ts';
 import type { Camera, PickHit, RasterLayerStats } from './wasm/isard.js';
+export type { LayerSpec } from './map/layer-spec.ts';
 /** A map (see `GeoMap.create`); layers take it as their host */
 export declare class GeoMap {
     #private;
     readonly canvas: HTMLCanvasElement;
-    /** Layers new layers go under */
-    private readonly onTop;
-    /** The vector basemap, if any: its tiles' workers and its labels */
-    private vector;
-    private readonly glyphsUrl;
-    private readonly basemapWorkerUrl;
-    /** Texture size of the vector basemap's tiles */
-    private readonly basemapTileSize;
+    /** The engine class (core, or with 3D Tiles) and the engine with 3D Tiles loaded when needed */
+    private readonly engines;
+    /** The layers in drawing order and those kept on top */
+    private readonly stack;
+    /** The basemap and the hillshade */
+    private readonly basemaps;
+    /** The glyphs and icons of the symbol layers */
+    private readonly atlases;
+    /** The workers of the vector tiles, the relief and the reprojected rasters */
+    private readonly workers;
     private readonly container;
-    /** Markers and popups, over the canvas */
-    private readonly overlay;
-    private readonly corners;
-    private readonly controls;
-    private readonly positioned;
-    /** Canvas size in CSS pixels, kept on resize so placing overlays never reads the layout */
-    private size;
-    /** Layers in drawing order (bottom first), to recreate them after a context loss */
-    private readonly layers;
+    /** The canvas in the container, the markers and popups over it, the controls in its corners */
+    private readonly overlays;
     private readonly settings;
     /** The WebGL context is lost: nothing is drawn until it is restored */
     private lost;
+    private gone;
     private readonly listeners;
+    /** Frames drawn on demand, with their events */
+    private readonly frames;
     private readonly resizeObserver;
     private readonly interaction;
-    private loader;
-    /** The class of the engine: without 3D Tiles until a 3D Tiles layer is added, unless asked for from the start */
-    private engineClass;
-    /** The module of the engine with 3D Tiles once it runs this map (the decoding workers run it too) */
-    private tiles3dModule;
-    /** The engine with 3D Tiles is loading, for the 3D Tiles layers added on the core engine */
-    private upgrading;
-    /** What loading the engine with 3D Tiles and its workers needs */
-    private readonly tiles3dOptions;
-    private gone;
     /** The map is of the Earth: a basemap by default */
     private readonly earth;
     /** The body, as the option named it */
     private readonly body;
-    private basemap;
-    private hillshade;
-    /** Called when the credits of the layers or relief change (the attribution controls) */
-    private readonly attributionListeners;
-    /** Credits of the raster layers that have some (basemaps, hillshade, the Géoplateforme's rasters…) */
-    private readonly rasterCredits;
-    private animation;
-    private hoverPoint;
-    /** Frame polling the engine for the answer of the hover picking, 0 if none */
-    private hoverPoll;
-    /** Polls of the hover picking under way: given up after `MAX_POLLS` (an answer that never comes) */
-    private hoverPolls;
+    /** Credits of the raster layers that have some, and the attribution controls told when they change */
+    private readonly credits;
+    /** The picking for 'hoverfeature', its answer emitted on a later frame */
+    private readonly hoverPick;
     /** What 'hoverfeature' looks for: within `radius` CSS pixels, in `layers` only if given */
-    hoverPicking: {
-        radius?: number;
-        layers?: readonly Layer[];
-    };
-    private frameRequest;
-    private lastCamera;
-    /** The camera moved since the last 'moveend' */
-    private moving;
-    /** The last frame found everything loaded ('idle' sent) */
-    private settled;
-    private inFrame;
-    /** The camera of the frame being drawn: what `getCamera` gives the custom layers while the engine is busy */
-    private frameCamera;
+    hoverPicking: HoverPicking;
     /** Vector tiles made by `vectorTiles()`, destroyed with the map */
     private readonly vectorSets;
-    /** The workers drawing vector tiles, shared by every `VectorTiles` of the map; created on first use */
-    private basemapPool;
     /** Stops watching the device pixel ratio */
-    private unwatchRatio;
+    private readonly unwatchRatio;
     /** Stops following the page's request headers (`setRequestHeaders`) */
     private unwatchHeaders;
     /** Stops listening to the canvas's context loss and restoration */
     private readonly unwatchContext;
-    /** The loaders of the relief by encoding, URL and floor: the same loader for the same tiles (the engine keeps its
-     * tiles when only the exaggeration changes) */
-    private readonly terrainLoaders;
     /** Loads the engine (once per page) and creates a map filling `container` */
     static create(container: HTMLElement, given?: GeoMapOptions): Promise<GeoMap>;
     private constructor();
     /** The element the map was created in */
     getContainer(): HTMLElement;
     getCanvas(): HTMLCanvasElement;
+    /** Layers in drawing order (bottom first) */
+    private get layers();
+    /** Layers new layers go under */
+    private get onTop();
     private createEngine;
-    /** The decoding workers of 3D Tiles, with the engine that has them (they run its module) and unless turned off */
-    private startLoader;
     /** A 3D Tiles layer or a model on the core engine: loads the engine with 3D Tiles, then rebuilds the map on it
      * (camera, settings and layers kept, as after a context loss); the layer is created then */
     private upgrade;
@@ -130,13 +99,7 @@ export declare class GeoMap {
      */
     setSwipe(options: SwipeOptions | undefined): void;
     private applySwipe;
-    /** Takes a layer out of the drawing order (to put it back elsewhere, or for good) */
-    private unlist;
     private addLayer;
-    /** Index in the engine of the layer at `index`: the layers waiting for the engine with 3D Tiles are not in it yet */
-    private engineIndex;
-    /** Moves a layer under all the others */
-    private toBottom;
     /** Listens to an event; returns the function that stops listening */
     on<K extends keyof MapEvents>(type: K, listener: (event: MapEvents[K]) => void): () => void;
     /**
@@ -199,18 +162,17 @@ export declare class GeoMap {
     setLoading(mode: LoadingMode): void;
     /** Space behind the globe (stars, atmosphere halo) */
     setSky(enabled: boolean): void;
+    /** The viewshed set, set again in a new engine */
+    private viewshed;
     /** Tints what can be seen from a point and what is hidden from it, within a range, all around or within a cone
      * (`direction`): the relief, extrusions, 3D Tiles and models hide what lies behind them (only what the map has
      * loaded for its view). Several observers (16 at most): what any of them sees is seen, what is hidden from all those
      * that reach it is hidden, in the colors and opacity of the first. Undefined or none removes it */
-    /** The viewshed set, set again in a new engine */
-    private viewshed;
     setViewshed(options: ViewshedOptions | readonly ViewshedOptions[] | undefined): void;
     /** Relief under the basemap: true for the body's terrain model (on the Earth the worldwide Terrain Tiles, NASA's
      * on the Moon and Mars), one of the Earth's models by name (`'ign'`), its options, or false; on another body, its
      * options with a `url` */
     setTerrain(terrain: boolean | TerrainModel | TerrainOptions): void;
-    private attributionChanged;
     /** Color behind the map, a CSS color (its alpha ignored) */
     setBackground(color: string): void;
     /** Tile counters of the raster layers, for diagnostics */
@@ -232,10 +194,6 @@ export declare class GeoMap {
     }): FeatureHit | undefined;
     /** A hit with its layer handle and feature; undefined if the layer is gone */
     private featureHit;
-    /** Asks the engine what is under the pointer; its answer, read without waiting for the GPU, comes on a later frame */
-    private requestHoverPick;
-    private readonly pollHoverPick;
-    private cancelHoverPick;
     /** Screen point (CSS pixels) of a position on the ground (the relief), or `height` metres above it, undefined
      * behind the camera */
     project(lonLat: LonLat, height?: number): Point | undefined;
@@ -325,15 +283,6 @@ export declare class GeoMap {
      * basemap.
      */
     vectorTiles(options?: VectorTilesOptions): VectorTiles;
-    /**
-     * The workers decoding the relief and reprojecting rasters: the map's pool, unless the map has no workers
-     * (`workers: false` or 0, or none in this browser): that is done in the page then
-     */
-    private decodingPool;
-    private readonly remoteHeights;
-    private readonly remoteReprojection;
-    /** The loader of the relief tiles of `url` in a PNG encoding (one per URL, encoding and floor) */
-    private readonly terrainLoader;
     /** Adds a layer, under `before` if given */
     private place;
     /** Textured meshes in 3D Tiles (photogrammetry, buildings), drawn with depth over the basemap */
@@ -358,42 +307,6 @@ export declare class GeoMap {
     }): CustomLayer;
     /** Asks for a frame; several calls before the next frame draw it once */
     requestRender(): void;
-    private frame;
-    private drawFrame;
-    /** Resizes when the device pixel ratio changes (browser zoom, a window moved to another screen) */
-    private watchRatio;
     private resize;
     destroy(): void;
 }
-/** A layer by its type and the options of its `add…` method (`GeoMap.add`) */
-export type LayerSpec<P = Record<string, unknown>> = ({
-    type: 'lines';
-} & LineOptions<P>) | ({
-    type: 'circles';
-} & CircleOptions<P>) | ({
-    type: 'fills';
-} & FillOptions<P>) | ({
-    type: 'symbols';
-} & SymbolOptions<P>) | ({
-    type: 'extrusions';
-} & ExtrusionOptions<P>) | ({
-    type: 'raster';
-} & RasterOptions & {
-    before?: Layer;
-}) | ({
-    type: 'ground';
-} & GroundOptions & {
-    before?: Layer;
-}) | ({
-    type: 'network';
-} & NetworkOptions) | ({
-    type: 'tiles3d';
-} & Tiles3dOptions) | ({
-    type: 'pointcloud';
-} & PointCloudOptions & {
-    before?: Layer;
-}) | ({
-    type: 'models';
-} & ModelOptions & {
-    before?: Layer;
-});