isard 1.1.0 → 1.3.0

package/dist/map/engines.js

@@ -0,0 +1,77 @@
+/**
+ * Which engine a map runs: the core one, or the one with 3D Tiles, from the start or loaded once a layer needs it
+ * (the map is rebuilt on it then); and the workers decoding its 3D Tiles, started with the first engine that has them.
+ */
+import { engineUrl, loadFullEngineLater, preloadFullEngine, startTileLoader, } from "../engine-loader.js";
+import { applySettings } from "./engine-settings.js";
+/** The engine class of a map, and the engine with 3D Tiles loaded when needed */
+export class MapEngines {
+    /** The class of the engine: without 3D Tiles until a 3D Tiles layer is added, unless asked for from the start */
+    engineClass;
+    /** The module of the engine with 3D Tiles once it runs the map (the decoding workers run it too) */
+    module;
+    #upgrading;
+    loader;
+    options;
+    /** The map is destroyed: a loaded engine is not used */
+    gone;
+    /** `module`: the module of the engine with 3D Tiles if `engineClass` is that engine */
+    constructor(engineClass, module, options, gone) {
+        this.engineClass = engineClass;
+        this.module = module;
+        this.options = { ...options };
+        this.gone = gone;
+    }
+    /** The engine with 3D Tiles runs the map */
+    get tiles3d() {
+        return this.module !== undefined;
+    }
+    /** The engine with 3D Tiles is loading, for the 3D Tiles layers added on the core engine */
+    get upgrading() {
+        return this.#upgrading;
+    }
+    /** A new engine drawing on `canvas`, with the settings and the decoding workers of 3D Tiles if it has them */
+    create(canvas, redraw, settings) {
+        const engine = new this.engineClass(canvas, redraw);
+        applySettings(engine, settings);
+        // The decoding workers of 3D Tiles, with the engine that has them (they run its module) and unless turned off
+        this.loader ??= this.module && startTileLoader(this.module, this.options, engine);
+        if (this.loader)
+            engine.setTileLoader(this.loader);
+        return engine;
+    }
+    /** Height of the geoid above the ellipsoid at a position, in metres */
+    geoidHeight(lon, lat) {
+        return this.engineClass.geoidHeight(lon, lat);
+    }
+    /** The matrix of a custom layer's model at a position */
+    customMatrix(lon, lat, altitude) {
+        return this.engineClass.customMatrix(lon, lat, altitude);
+    }
+    /** Loads the engine with 3D Tiles, once at a time: `loaded` once it is the map's class, `failed` with the error;
+     * neither if the map is gone by then */
+    upgrade(loaded, failed) {
+        this.#upgrading ??= loadFullEngineLater(engineUrl('full', this.options)).then(({ module, Engine }) => {
+            this.#upgrading = undefined;
+            if (this.gone())
+                return;
+            this.engineClass = Engine;
+            this.module = module;
+            loaded();
+        }, (error) => {
+            this.#upgrading = undefined;
+            if (this.gone())
+                return;
+            failed(error);
+        });
+    }
+    /** Downloads and compiles the engine with 3D Tiles without running it, unless the map is gone or has it by then */
+    preload() {
+        preloadFullEngine(engineUrl('full', this.options), () => !this.gone() && !this.module);
+    }
+    /** Stops the decoding workers */
+    destroy() {
+        this.loader?.destroy();
+    }
+}
+//# sourceMappingURL=engines.js.map

package/dist/map/engines.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"engines.js","sourceRoot":"","sources":["../../src/map/engines.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAEL,SAAS,EACT,mBAAmB,EACnB,iBAAiB,EACjB,eAAe,GAChB,MAAM,qBAAqB,CAAC;AAI7B,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AAQrD,iFAAiF;AACjF,MAAM,OAAO,UAAU;IACrB,iHAAiH;IACzG,WAAW,CAAc;IACjC,oGAAoG;IAC5F,MAAM,CAAiC;IAC/C,UAAU,CAA4B;IAC9B,MAAM,CAAyB;IACtB,OAAO,CAAuB;IAC/C,wDAAwD;IACvC,IAAI,CAAgB;IAErC,uFAAuF;IACvF,YACE,WAAwB,EACxB,MAAsC,EACtC,OAA6B,EAC7B,IAAmB;QAEnB,IAAI,CAAC,WAAW,GAAG,WAAW,CAAC;QAC/B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,OAAO,GAAG,EAAE,GAAG,OAAO,EAAE,CAAC;QAC9B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;IACnB,CAAC;IAED,4CAA4C;IAC5C,IAAI,OAAO;QACT,OAAO,IAAI,CAAC,MAAM,KAAK,SAAS,CAAC;IACnC,CAAC;IAED,4FAA4F;IAC5F,IAAI,SAAS;QACX,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,8GAA8G;IAC9G,MAAM,CAAC,MAAyB,EAAE,MAAkB,EAAE,QAAkB;QACtE,MAAM,MAAM,GAAG,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;QAEpD,aAAa,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC;QAChC,8GAA8G;QAC9G,IAAI,CAAC,MAAM,KAAK,IAAI,CAAC,MAAM,IAAI,eAAe,CAAC,IAAI,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,CAAC;QAClF,IAAI,IAAI,CAAC,MAAM;YAAE,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QAEnD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,uEAAuE;IACvE,WAAW,CAAC,GAAW,EAAE,GAAW;QAClC,OAAO,IAAI,CAAC,WAAW,CAAC,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC;IAChD,CAAC;IAED,yDAAyD;IACzD,YAAY,CAAC,GAAW,EAAE,GAAW,EAAE,QAAgB;QACrD,OAAO,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,GAAG,EAAE,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC3D,CAAC;IAED;4CACwC;IACxC,OAAO,CAAC,MAAkB,EAAE,MAAgC;QAC1D,IAAI,CAAC,UAAU,KAAK,mBAAmB,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAC3E,CAAC,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE;YACrB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,EAAE;gBAAE,OAAO;YACxB,IAAI,CAAC,WAAW,GAAG,MAAM,CAAC;YAC1B,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;YACrB,MAAM,EAAE,CAAC;QACX,CAAC,EACD,CAAC,KAAc,EAAE,EAAE;YACjB,IAAI,CAAC,UAAU,GAAG,SAAS,CAAC;YAC5B,IAAI,IAAI,CAAC,IAAI,EAAE;gBAAE,OAAO;YACxB,MAAM,CAAC,KAAK,CAAC,CAAC;QAChB,CAAC,CACF,CAAC;IACJ,CAAC;IAED,mHAAmH;IACnH,OAAO;QACL,iBAAiB,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzF,CAAC;IAED,iCAAiC;IACjC,OAAO;QACL,IAAI,CAAC,MAAM,EAAE,OAAO,EAAE,CAAC;IACzB,CAAC;CACF","sourcesContent":["/**\n * Which engine a map runs: the core one, or the one with 3D Tiles, from the start or loaded once a layer needs it\n * (the map is rebuilt on it then); and the workers decoding its 3D Tiles, started with the first engine that has them.\n */\n\nimport type { TileLoader } from '../engine/loader.ts';\nimport {\n  type EngineClass,\n  engineUrl,\n  loadFullEngineLater,\n  preloadFullEngine,\n  startTileLoader,\n} from '../engine-loader.ts';\nimport type { Settings } from '../settings.ts';\nimport type { GeoMapOptions } from '../types.ts';\nimport type { Engine } from '../wasm/isard.js';\nimport { applySettings } from './engine-settings.ts';\n\n/** What loading the engine with 3D Tiles and its workers needs */\nexport type Tiles3dEngineOptions = Pick<\n  GeoMapOptions,\n  'wasmUrl' | 'workers' | 'workerUrl' | 'decoders' | 'pointsWasmUrl' | 'assetsUrl'\n>;\n\n/** The engine class of a map, and the engine with 3D Tiles loaded when needed */\nexport class MapEngines {\n  /** The class of the engine: without 3D Tiles until a 3D Tiles layer is added, unless asked for from the start */\n  private engineClass: EngineClass;\n  /** The module of the engine with 3D Tiles once it runs the map (the decoding workers run it too) */\n  private module: WebAssembly.Module | undefined;\n  #upgrading: Promise<void> | undefined;\n  private loader: TileLoader | undefined;\n  private readonly options: Tiles3dEngineOptions;\n  /** The map is destroyed: a loaded engine is not used */\n  private readonly gone: () => boolean;\n\n  /** `module`: the module of the engine with 3D Tiles if `engineClass` is that engine */\n  constructor(\n    engineClass: EngineClass,\n    module: WebAssembly.Module | undefined,\n    options: Tiles3dEngineOptions,\n    gone: () => boolean,\n  ) {\n    this.engineClass = engineClass;\n    this.module = module;\n    this.options = { ...options };\n    this.gone = gone;\n  }\n\n  /** The engine with 3D Tiles runs the map */\n  get tiles3d(): boolean {\n    return this.module !== undefined;\n  }\n\n  /** The engine with 3D Tiles is loading, for the 3D Tiles layers added on the core engine */\n  get upgrading(): Promise<void> | undefined {\n    return this.#upgrading;\n  }\n\n  /** A new engine drawing on `canvas`, with the settings and the decoding workers of 3D Tiles if it has them */\n  create(canvas: HTMLCanvasElement, redraw: () => void, settings: Settings): Engine {\n    const engine = new this.engineClass(canvas, redraw);\n\n    applySettings(engine, settings);\n    // The decoding workers of 3D Tiles, with the engine that has them (they run its module) and unless turned off\n    this.loader ??= this.module && startTileLoader(this.module, this.options, engine);\n    if (this.loader) engine.setTileLoader(this.loader);\n\n    return engine;\n  }\n\n  /** Height of the geoid above the ellipsoid at a position, in metres */\n  geoidHeight(lon: number, lat: number): number {\n    return this.engineClass.geoidHeight(lon, lat);\n  }\n\n  /** The matrix of a custom layer's model at a position */\n  customMatrix(lon: number, lat: number, altitude: number): Float32Array | undefined {\n    return this.engineClass.customMatrix(lon, lat, altitude);\n  }\n\n  /** Loads the engine with 3D Tiles, once at a time: `loaded` once it is the map's class, `failed` with the error;\n   * neither if the map is gone by then */\n  upgrade(loaded: () => void, failed: (error: unknown) => void): void {\n    this.#upgrading ??= loadFullEngineLater(engineUrl('full', this.options)).then(\n      ({ module, Engine }) => {\n        this.#upgrading = undefined;\n        if (this.gone()) return;\n        this.engineClass = Engine;\n        this.module = module;\n        loaded();\n      },\n      (error: unknown) => {\n        this.#upgrading = undefined;\n        if (this.gone()) return;\n        failed(error);\n      },\n    );\n  }\n\n  /** Downloads and compiles the engine with 3D Tiles without running it, unless the map is gone or has it by then */\n  preload(): void {\n    preloadFullEngine(engineUrl('full', this.options), () => !this.gone() && !this.module);\n  }\n\n  /** Stops the decoding workers */\n  destroy(): void {\n    this.loader?.destroy();\n  }\n}\n"]}

package/dist/map/events.d.ts

@@ -0,0 +1,14 @@
+/** The listeners of the map's events: added, called, cleared with the map. */
+import type { MapEvents } from '../types.ts';
+/** The listeners of the map's events, by type */
+export declare class MapListeners {
+    private readonly listeners;
+    /** Listens to an event; returns the function that stops listening */
+    on<K extends keyof MapEvents>(type: K, listener: (event: MapEvents[K]) => void): () => void;
+    /** Calls the listeners; one that throws is reported and does not stop the others nor the frame */
+    emit<K extends keyof MapEvents>(type: K, event: MapEvents[K]): void;
+    /** Something listens to `type` */
+    has(type: keyof MapEvents): boolean;
+    /** Forgets every listener */
+    clear(): void;
+}

package/dist/map/events.js

@@ -0,0 +1,46 @@
+/** The listeners of the map's events: added, called, cleared with the map. */
+import { report } from "./checks.js";
+/** The listeners of the map's events, by type */
+export class MapListeners {
+    listeners = {
+        movestart: new Set(),
+        move: new Set(),
+        moveend: new Set(),
+        resize: new Set(),
+        hover: new Set(),
+        hoverfeature: new Set(),
+        click: new Set(),
+        render: new Set(),
+        idle: new Set(),
+        leave: new Set(),
+    };
+    /** Listens to an event; returns the function that stops listening */
+    on(type, listener) {
+        const listeners = this.listeners[type];
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+    }
+    /** Calls the listeners; one that throws is reported and does not stop the others nor the frame */
+    emit(type, event) {
+        const listeners = this.listeners[type];
+        listeners.forEach((listener) => {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                report(error);
+            }
+        });
+    }
+    /** Something listens to `type` */
+    has(type) {
+        return this.listeners[type].size > 0;
+    }
+    /** Forgets every listener */
+    clear() {
+        Object.values(this.listeners).forEach((listeners) => {
+            listeners.clear();
+        });
+    }
+}
+//# sourceMappingURL=events.js.map

package/dist/map/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/map/events.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAG9E,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAIrC,iDAAiD;AACjD,MAAM,OAAO,YAAY;IACN,SAAS,GAAc;QACtC,SAAS,EAAE,IAAI,GAAG,EAAE;QACpB,IAAI,EAAE,IAAI,GAAG,EAAE;QACf,OAAO,EAAE,IAAI,GAAG,EAAE;QAClB,MAAM,EAAE,IAAI,GAAG,EAAE;QACjB,KAAK,EAAE,IAAI,GAAG,EAAE;QAChB,YAAY,EAAE,IAAI,GAAG,EAAE;QACvB,KAAK,EAAE,IAAI,GAAG,EAAE;QAChB,MAAM,EAAE,IAAI,GAAG,EAAE;QACjB,IAAI,EAAE,IAAI,GAAG,EAAE;QACf,KAAK,EAAE,IAAI,GAAG,EAAE;KACjB,CAAC;IAEF,qEAAqE;IACrE,EAAE,CAA4B,IAAO,EAAE,QAAuC;QAC5E,MAAM,SAAS,GAAuC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAE3E,SAAS,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAExB,OAAO,GAAG,EAAE,CAAC,SAAS,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC1C,CAAC;IAED,kGAAkG;IAClG,IAAI,CAA4B,IAAO,EAAE,KAAmB;QAC1D,MAAM,SAAS,GAAuC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAE3E,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE;YAC7B,IAAI,CAAC;gBACH,QAAQ,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC;QACH,CAAC,CAAC,CAAC;IACL,CAAC;IAED,kCAAkC;IAClC,GAAG,CAAC,IAAqB;QACvB,OAAO,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC;IACvC,CAAC;IAED,6BAA6B;IAC7B,KAAK;QACH,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,OAAO,CAAC,CAAC,SAAS,EAAE,EAAE;YAClD,SAAS,CAAC,KAAK,EAAE,CAAC;QACpB,CAAC,CAAC,CAAC;IACL,CAAC;CACF","sourcesContent":["/** The listeners of the map's events: added, called, cleared with the map. */\n\nimport type { MapEvents } from '../types.ts';\nimport { report } from './checks.ts';\n\ntype Listeners = { [K in keyof MapEvents]: Set<(event: MapEvents[K]) => void> };\n\n/** The listeners of the map's events, by type */\nexport class MapListeners {\n  private readonly listeners: Listeners = {\n    movestart: new Set(),\n    move: new Set(),\n    moveend: new Set(),\n    resize: new Set(),\n    hover: new Set(),\n    hoverfeature: new Set(),\n    click: new Set(),\n    render: new Set(),\n    idle: new Set(),\n    leave: new Set(),\n  };\n\n  /** Listens to an event; returns the function that stops listening */\n  on<K extends keyof MapEvents>(type: K, listener: (event: MapEvents[K]) => void): () => void {\n    const listeners: Set<(event: MapEvents[K]) => void> = this.listeners[type];\n\n    listeners.add(listener);\n\n    return () => listeners.delete(listener);\n  }\n\n  /** Calls the listeners; one that throws is reported and does not stop the others nor the frame */\n  emit<K extends keyof MapEvents>(type: K, event: MapEvents[K]): void {\n    const listeners: Set<(event: MapEvents[K]) => void> = this.listeners[type];\n\n    listeners.forEach((listener) => {\n      try {\n        listener(event);\n      } catch (error) {\n        report(error);\n      }\n    });\n  }\n\n  /** Something listens to `type` */\n  has(type: keyof MapEvents): boolean {\n    return this.listeners[type].size > 0;\n  }\n\n  /** Forgets every listener */\n  clear(): void {\n    Object.values(this.listeners).forEach((listeners) => {\n      listeners.clear();\n    });\n  }\n}\n"]}

package/dist/map/frame-loop.d.ts

@@ -0,0 +1,64 @@
+/**
+ * The frame loop of a map: frames drawn on demand only (an idle map costs nothing), the running animation stepped in
+ * each, and the events of a frame sent with it: the camera's moves, the pointer's position (coalesced to one per
+ * frame, so the values computed for it are drawn in the same frame), 'render', and 'idle' once everything is loaded.
+ */
+import type { Point } from '../types.ts';
+import type { Step } from '../util/animation.ts';
+import type { Camera, Engine } from '../wasm/isard.js';
+import type { MapListeners } from './events.ts';
+/** What the frame loop needs of its map */
+export interface FrameHost {
+    /** The map's engine of the moment */
+    engine(): Engine;
+    /** The map's camera */
+    camera(): Camera;
+    /** The WebGL context is lost: nothing is drawn */
+    lost(): boolean;
+    /** The pointer or the keys are moving the camera: no 'moveend' yet */
+    interacting(): boolean;
+    /** Custom layers are drawn: they read the camera of the frame */
+    customLayers(): boolean;
+    /** The engine with 3D Tiles is loading: not idle */
+    upgrading(): boolean;
+    /** The frame is drawn: what follows it (the overlays placed, the hover picking asked for at `hovered`) */
+    drawn(hovered: Point | undefined): void;
+}
+/** The frames of a map, asked for and drawn */
+export declare class FrameLoop {
+    #private;
+    private readonly host;
+    private readonly listeners;
+    /** Frame asked for, 0 if none */
+    private requested;
+    private inFrame;
+    private animation;
+    /** The pointer's position for the next frame */
+    private hoverPoint;
+    private lastCamera;
+    /** The camera moved since the last 'moveend' */
+    private moving;
+    /** `listeners`: the map's, told of the frame's events */
+    constructor(host: FrameHost, listeners: MapListeners);
+    /** The last frame found everything loaded ('idle' sent) */
+    get settled(): boolean;
+    /** The camera of the frame being drawn: what `getCamera` gives the custom layers while the engine is busy */
+    get camera(): Camera | undefined;
+    /** Asks for a frame; several calls before the next frame draw it once */
+    request(): void;
+    /** Asks for a frame that sends 'idle' once everything is loaded, even if the last one already did: the waiters of
+     * `whenIdle` on a map already idle (else no frame would change from loading to loaded, and none would send it) */
+    requestIdle(): void;
+    /** Runs `step` every frame until it returns false; replaces the running animation */
+    animate(step: Step | undefined): void;
+    /** The pointer's position for the next frame (undefined: none) */
+    hover(point: Point | undefined): void;
+    /** Draws a frame now, in place of the one asked for (a resized canvas is cleared: waiting one frame would flash) */
+    drawNow(): void;
+    /** Cancels the frame asked for (the context is lost); a new one can be asked for */
+    cancel(): void;
+    /** Cancels the frame asked for, for good (the map is destroyed): it stays marked as asked for */
+    stop(): void;
+    private frame;
+    private draw;
+}

package/dist/map/frame-loop.js

@@ -0,0 +1,145 @@
+/**
+ * The frame loop of a map: frames drawn on demand only (an idle map costs nothing), the running animation stepped in
+ * each, and the events of a frame sent with it: the camera's moves, the pointer's position (coalesced to one per
+ * frame, so the values computed for it are drawn in the same frame), 'render', and 'idle' once everything is loaded.
+ */
+/** The frames of a map, asked for and drawn */
+export class FrameLoop {
+    host;
+    listeners;
+    /** Frame asked for, 0 if none */
+    requested = 0;
+    inFrame = false;
+    animation;
+    /** The pointer's position for the next frame */
+    hoverPoint;
+    lastCamera = '';
+    /** The camera moved since the last 'moveend' */
+    moving = false;
+    #settled = false;
+    #camera;
+    /** `listeners`: the map's, told of the frame's events */
+    constructor(host, listeners) {
+        this.host = host;
+        this.listeners = listeners;
+    }
+    /** The last frame found everything loaded ('idle' sent) */
+    get settled() {
+        return this.#settled;
+    }
+    /** The camera of the frame being drawn: what `getCamera` gives the custom layers while the engine is busy */
+    get camera() {
+        return this.#camera;
+    }
+    /** Asks for a frame; several calls before the next frame draw it once */
+    request() {
+        // Changes made by listeners during a frame are drawn by that frame; nothing is drawn without a context
+        if (this.inFrame || this.host.lost())
+            return;
+        this.requested ||= requestAnimationFrame((now) => this.frame(now));
+    }
+    /** Asks for a frame that sends 'idle' once everything is loaded, even if the last one already did: the waiters of
+     * `whenIdle` on a map already idle (else no frame would change from loading to loaded, and none would send it) */
+    requestIdle() {
+        this.#settled = false;
+        this.request();
+    }
+    /** Runs `step` every frame until it returns false; replaces the running animation */
+    animate(step) {
+        // A flight cut short no longer needs its destination
+        if (this.animation)
+            this.host.engine().clearPreload();
+        this.animation = step;
+        this.request();
+    }
+    /** The pointer's position for the next frame (undefined: none) */
+    hover(point) {
+        this.hoverPoint = point;
+    }
+    /** Draws a frame now, in place of the one asked for (a resized canvas is cleared: waiting one frame would flash) */
+    drawNow() {
+        cancelAnimationFrame(this.requested);
+        this.frame(performance.now());
+    }
+    /** Cancels the frame asked for (the context is lost); a new one can be asked for */
+    cancel() {
+        cancelAnimationFrame(this.requested);
+        this.requested = 0;
+    }
+    /** Cancels the frame asked for, for good (the map is destroyed): it stays marked as asked for */
+    stop() {
+        cancelAnimationFrame(this.requested);
+    }
+    frame(now) {
+        this.requested = 0;
+        try {
+            this.inFrame = true;
+            this.draw(now);
+        }
+        finally {
+            // Whatever throws in a frame, the next ones are still drawn
+            this.inFrame = false;
+        }
+    }
+    draw(now) {
+        if (this.animation && !this.animation(now))
+            this.animation = undefined;
+        const { host, listeners } = this;
+        const camera = host.camera();
+        const key = `${camera.center}|${camera.zoom}|${camera.pitch}|${camera.bearing}`;
+        const moved = key !== this.lastCamera;
+        if (moved) {
+            // The first frame is no move
+            if (!this.moving && this.lastCamera !== '') {
+                this.moving = true;
+                listeners.emit('movestart', camera);
+            }
+            this.lastCamera = key;
+            listeners.emit('move', camera);
+        }
+        else if (this.moving && !this.animation && !host.interacting()) {
+            this.moving = false;
+            listeners.emit('moveend', camera);
+        }
+        // Values for the pointer position are computed before drawing, in the same frame
+        const hovered = this.hoverPoint;
+        if (hovered) {
+            this.hoverPoint = undefined;
+            // The position under the pointer for its listeners only (a 'hoverfeature' alone does not need it)
+            if (listeners.has('hover')) {
+                listeners.emit('hover', { point: hovered, lonLat: host.engine().ground(hovered[0], hovered[1]) });
+            }
+        }
+        const t0 = performance.now();
+        // The engine asks for the next frame while it draws (uploads past the frame budget, fades): not ignored
+        this.inFrame = false;
+        // As the engine has it now (a listener may have moved it), for the custom layers drawn in the frame
+        this.#camera = host.customLayers() ? host.engine().camera() : undefined;
+        const render = () => {
+            try {
+                return host.engine().render();
+            }
+            finally {
+                this.#camera = undefined;
+            }
+        };
+        const loading = render();
+        this.inFrame = true;
+        host.drawn(hovered);
+        listeners.emit('render', { ms: performance.now() - t0 });
+        this.inFrame = false;
+        // A move goes on until a frame finds the camera still: that frame sends 'moveend'
+        if (this.animation || (moved && this.moving))
+            this.request();
+        // Idle: nothing loading (the engine with 3D Tiles neither), no animation, no frame asked for (uploads waiting,
+        // fades, listeners)
+        if (loading || host.upgrading() || this.animation || this.requested !== 0) {
+            this.#settled = false;
+        }
+        else if (!this.#settled) {
+            this.#settled = true;
+            listeners.emit('idle', {});
+        }
+    }
+}
+//# sourceMappingURL=frame-loop.js.map

package/dist/map/frame-loop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frame-loop.js","sourceRoot":"","sources":["../../src/map/frame-loop.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The frame loop of a map: frames drawn on demand only (an idle map costs nothing), the running animation stepped in\n * each, and the events of a frame sent with it: the camera's moves, the pointer's position (coalesced to one per\n * frame, so the values computed for it are drawn in the same frame), 'render', and 'idle' once everything is loaded.\n */\n\nimport type { Point } from '../types.ts';\nimport type { Step } from '../util/animation.ts';\nimport type { Camera, Engine } from '../wasm/isard.js';\nimport type { MapListeners } from './events.ts';\n\n/** What the frame loop needs of its map */\nexport interface FrameHost {\n  /** The map's engine of the moment */\n  engine(): Engine;\n  /** The map's camera */\n  camera(): Camera;\n  /** The WebGL context is lost: nothing is drawn */\n  lost(): boolean;\n  /** The pointer or the keys are moving the camera: no 'moveend' yet */\n  interacting(): boolean;\n  /** Custom layers are drawn: they read the camera of the frame */\n  customLayers(): boolean;\n  /** The engine with 3D Tiles is loading: not idle */\n  upgrading(): boolean;\n  /** The frame is drawn: what follows it (the overlays placed, the hover picking asked for at `hovered`) */\n  drawn(hovered: Point | undefined): void;\n}\n\n/** The frames of a map, asked for and drawn */\nexport class FrameLoop {\n  private readonly host: FrameHost;\n  private readonly listeners: MapListeners;\n  /** Frame asked for, 0 if none */\n  private requested = 0;\n  private inFrame = false;\n  private animation: Step | undefined;\n  /** The pointer's position for the next frame */\n  private hoverPoint: Point | undefined;\n  private lastCamera = '';\n  /** The camera moved since the last 'moveend' */\n  private moving = false;\n  #settled = false;\n  #camera: Camera | undefined;\n\n  /** `listeners`: the map's, told of the frame's events */\n  constructor(host: FrameHost, listeners: MapListeners) {\n    this.host = host;\n    this.listeners = listeners;\n  }\n\n  /** The last frame found everything loaded ('idle' sent) */\n  get settled(): boolean {\n    return this.#settled;\n  }\n\n  /** The camera of the frame being drawn: what `getCamera` gives the custom layers while the engine is busy */\n  get camera(): Camera | undefined {\n    return this.#camera;\n  }\n\n  /** Asks for a frame; several calls before the next frame draw it once */\n  request(): void {\n    // Changes made by listeners during a frame are drawn by that frame; nothing is drawn without a context\n    if (this.inFrame || this.host.lost()) return;\n    this.requested ||= requestAnimationFrame((now) => this.frame(now));\n  }\n\n  /** Asks for a frame that sends 'idle' once everything is loaded, even if the last one already did: the waiters of\n   * `whenIdle` on a map already idle (else no frame would change from loading to loaded, and none would send it) */\n  requestIdle(): void {\n    this.#settled = false;\n    this.request();\n  }\n\n  /** Runs `step` every frame until it returns false; replaces the running animation */\n  animate(step: Step | undefined): void {\n    // A flight cut short no longer needs its destination\n    if (this.animation) this.host.engine().clearPreload();\n    this.animation = step;\n    this.request();\n  }\n\n  /** The pointer's position for the next frame (undefined: none) */\n  hover(point: Point | undefined): void {\n    this.hoverPoint = point;\n  }\n\n  /** Draws a frame now, in place of the one asked for (a resized canvas is cleared: waiting one frame would flash) */\n  drawNow(): void {\n    cancelAnimationFrame(this.requested);\n    this.frame(performance.now());\n  }\n\n  /** Cancels the frame asked for (the context is lost); a new one can be asked for */\n  cancel(): void {\n    cancelAnimationFrame(this.requested);\n    this.requested = 0;\n  }\n\n  /** Cancels the frame asked for, for good (the map is destroyed): it stays marked as asked for */\n  stop(): void {\n    cancelAnimationFrame(this.requested);\n  }\n\n  private frame(now: number): void {\n    this.requested = 0;\n    try {\n      this.inFrame = true;\n      this.draw(now);\n    } finally {\n      // Whatever throws in a frame, the next ones are still drawn\n      this.inFrame = false;\n    }\n  }\n\n  private draw(now: number): void {\n    if (this.animation && !this.animation(now)) this.animation = undefined;\n\n    const { host, listeners } = this;\n    const camera = host.camera();\n    const key = `${camera.center}|${camera.zoom}|${camera.pitch}|${camera.bearing}`;\n    const moved = key !== this.lastCamera;\n\n    if (moved) {\n      // The first frame is no move\n      if (!this.moving && this.lastCamera !== '') {\n        this.moving = true;\n        listeners.emit('movestart', camera);\n      }\n      this.lastCamera = key;\n      listeners.emit('move', camera);\n    } else if (this.moving && !this.animation && !host.interacting()) {\n      this.moving = false;\n      listeners.emit('moveend', camera);\n    }\n\n    // Values for the pointer position are computed before drawing, in the same frame\n    const hovered = this.hoverPoint;\n\n    if (hovered) {\n      this.hoverPoint = undefined;\n      // The position under the pointer for its listeners only (a 'hoverfeature' alone does not need it)\n      if (listeners.has('hover')) {\n        listeners.emit('hover', { point: hovered, lonLat: host.engine().ground(hovered[0], hovered[1]) });\n      }\n    }\n\n    const t0 = performance.now();\n\n    // The engine asks for the next frame while it draws (uploads past the frame budget, fades): not ignored\n    this.inFrame = false;\n    // As the engine has it now (a listener may have moved it), for the custom layers drawn in the frame\n    this.#camera = host.customLayers() ? host.engine().camera() : undefined;\n\n    const render = (): boolean => {\n      try {\n        return host.engine().render();\n      } finally {\n        this.#camera = undefined;\n      }\n    };\n    const loading = render();\n\n    this.inFrame = true;\n    host.drawn(hovered);\n    listeners.emit('render', { ms: performance.now() - t0 });\n    this.inFrame = false;\n    // A move goes on until a frame finds the camera still: that frame sends 'moveend'\n    if (this.animation || (moved && this.moving)) this.request();\n    // Idle: nothing loading (the engine with 3D Tiles neither), no animation, no frame asked for (uploads waiting,\n    // fades, listeners)\n    if (loading || host.upgrading() || this.animation || this.requested !== 0) {\n      this.#settled = false;\n    } else if (!this.#settled) {\n      this.#settled = true;\n      listeners.emit('idle', {});\n    }\n  }\n}\n"]}

package/dist/map/hover-pick.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The picking of what is under the pointer for 'hoverfeature', without stalling the GPU: the engine is asked once the
+ * frame is drawn, its answer read on a later frame, when the GPU is done.
+ */
+import type { Layer } from '../layers/layers.ts';
+import type { Point } from '../types.ts';
+import type { Engine, PickResult } from '../wasm/isard.js';
+/** What 'hoverfeature' looks for: within `radius` CSS pixels, in `layers` only if given */
+export interface HoverPicking {
+    radius?: number;
+    layers?: readonly Layer[];
+}
+/** The hover picking of a map: one request in flight at most, its answer polled frame after frame */
+export declare class HoverPick {
+    private readonly engine;
+    /** The WebGL context is lost: no answer will come */
+    private readonly lost;
+    private readonly answer;
+    /** Frame polling the engine for the answer, 0 if none */
+    private poll;
+    /** Polls under way: given up after `MAX_POLLS` (an answer that never comes) */
+    private polls;
+    /** `engine`: the map's engine of the moment; `answer`: called with what the engine found */
+    constructor(engine: () => Engine, lost: () => boolean, answer: (result: PickResult) => void);
+    /** Asks the engine what is under the pointer; its answer, read without waiting for the GPU, comes on a later frame */
+    request(point: Point, { radius, layers }: HoverPicking): void;
+    /** Stops waiting for the answer */
+    cancel(): void;
+    private readonly next;
+}

package/dist/map/hover-pick.js

@@ -0,0 +1,56 @@
+/**
+ * The picking of what is under the pointer for 'hoverfeature', without stalling the GPU: the engine is asked once the
+ * frame is drawn, its answer read on a later frame, when the GPU is done.
+ */
+/** Frames the hover picking waits for its answer at most (usually one) */
+const MAX_POLLS = 30;
+/** The hover picking of a map: one request in flight at most, its answer polled frame after frame */
+export class HoverPick {
+    engine;
+    /** The WebGL context is lost: no answer will come */
+    lost;
+    answer;
+    /** Frame polling the engine for the answer, 0 if none */
+    poll = 0;
+    /** Polls under way: given up after `MAX_POLLS` (an answer that never comes) */
+    polls = 0;
+    /** `engine`: the map's engine of the moment; `answer`: called with what the engine found */
+    constructor(engine, lost, answer) {
+        this.engine = engine;
+        this.lost = lost;
+        this.answer = answer;
+    }
+    /** Asks the engine what is under the pointer; its answer, read without waiting for the GPU, comes on a later frame */
+    request(point, { radius = 0, layers }) {
+        const only = layers && Uint32Array.from(layers.map((l) => l.id));
+        // The engine cannot pick (no request in flight): the poll under way would wait for nothing
+        if (!this.engine().requestPick(point[0], point[1], radius, only)) {
+            this.cancel();
+            return;
+        }
+        // A new request replaces the one in flight (in the engine too): one poll loop at most
+        this.polls = 0;
+        if (!this.poll)
+            this.poll = requestAnimationFrame(this.next);
+    }
+    /** Stops waiting for the answer */
+    cancel() {
+        cancelAnimationFrame(this.poll);
+        this.poll = 0;
+    }
+    next = () => {
+        this.poll = 0;
+        if (this.lost())
+            return;
+        const result = this.engine().pollPick();
+        if (!result) {
+            // The GPU is not done yet (usually a frame): asked again next frame, without drawing; given up at last
+            this.polls += 1;
+            if (this.polls < MAX_POLLS)
+                this.poll = requestAnimationFrame(this.next);
+            return;
+        }
+        this.answer(result);
+    };
+}
+//# sourceMappingURL=hover-pick.js.map

package/dist/map/hover-pick.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hover-pick.js","sourceRoot":"","sources":["../../src/map/hover-pick.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAMH,0EAA0E;AAC1E,MAAM,SAAS,GAAG,EAAE,CAAC;AAQrB,qGAAqG;AACrG,MAAM,OAAO,SAAS;IACH,MAAM,CAAe;IACtC,qDAAqD;IACpC,IAAI,CAAgB;IACpB,MAAM,CAA+B;IACtD,yDAAyD;IACjD,IAAI,GAAG,CAAC,CAAC;IACjB,+EAA+E;IACvE,KAAK,GAAG,CAAC,CAAC;IAElB,4FAA4F;IAC5F,YAAY,MAAoB,EAAE,IAAmB,EAAE,MAAoC;QACzF,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;IACvB,CAAC;IAED,sHAAsH;IACtH,OAAO,CAAC,KAAY,EAAE,EAAE,MAAM,GAAG,CAAC,EAAE,MAAM,EAAgB;QACxD,MAAM,IAAI,GAAG,MAAM,IAAI,WAAW,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;QAEjE,2FAA2F;QAC3F,IAAI,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,CAAC;YACjE,IAAI,CAAC,MAAM,EAAE,CAAC;YAEd,OAAO;QACT,CAAC;QACD,sFAAsF;QACtF,IAAI,CAAC,KAAK,GAAG,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,CAAC,IAAI;YAAE,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC/D,CAAC;IAED,mCAAmC;IACnC,MAAM;QACJ,oBAAoB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;IAChB,CAAC;IAEgB,IAAI,GAAG,GAAS,EAAE;QACjC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC;QACd,IAAI,IAAI,CAAC,IAAI,EAAE;YAAE,OAAO;QAExB,MAAM,MAAM,GAA2B,IAAI,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC;QAEhE,IAAI,CAAC,MAAM,EAAE,CAAC;YACZ,uGAAuG;YACvG,IAAI,CAAC,KAAK,IAAI,CAAC,CAAC;YAChB,IAAI,IAAI,CAAC,KAAK,GAAG,SAAS;gBAAE,IAAI,CAAC,IAAI,GAAG,qBAAqB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YAEzE,OAAO;QACT,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;IACtB,CAAC,CAAC;CACH","sourcesContent":["/**\n * The picking of what is under the pointer for 'hoverfeature', without stalling the GPU: the engine is asked once the\n * frame is drawn, its answer read on a later frame, when the GPU is done.\n */\n\nimport type { Layer } from '../layers/layers.ts';\nimport type { Point } from '../types.ts';\nimport type { Engine, PickResult } from '../wasm/isard.js';\n\n/** Frames the hover picking waits for its answer at most (usually one) */\nconst MAX_POLLS = 30;\n\n/** What 'hoverfeature' looks for: within `radius` CSS pixels, in `layers` only if given */\nexport interface HoverPicking {\n  radius?: number;\n  layers?: readonly Layer[];\n}\n\n/** The hover picking of a map: one request in flight at most, its answer polled frame after frame */\nexport class HoverPick {\n  private readonly engine: () => Engine;\n  /** The WebGL context is lost: no answer will come */\n  private readonly lost: () => boolean;\n  private readonly answer: (result: PickResult) => void;\n  /** Frame polling the engine for the answer, 0 if none */\n  private poll = 0;\n  /** Polls under way: given up after `MAX_POLLS` (an answer that never comes) */\n  private polls = 0;\n\n  /** `engine`: the map's engine of the moment; `answer`: called with what the engine found */\n  constructor(engine: () => Engine, lost: () => boolean, answer: (result: PickResult) => void) {\n    this.engine = engine;\n    this.lost = lost;\n    this.answer = answer;\n  }\n\n  /** Asks the engine what is under the pointer; its answer, read without waiting for the GPU, comes on a later frame */\n  request(point: Point, { radius = 0, layers }: HoverPicking): void {\n    const only = layers && Uint32Array.from(layers.map((l) => l.id));\n\n    // The engine cannot pick (no request in flight): the poll under way would wait for nothing\n    if (!this.engine().requestPick(point[0], point[1], radius, only)) {\n      this.cancel();\n\n      return;\n    }\n    // A new request replaces the one in flight (in the engine too): one poll loop at most\n    this.polls = 0;\n    if (!this.poll) this.poll = requestAnimationFrame(this.next);\n  }\n\n  /** Stops waiting for the answer */\n  cancel(): void {\n    cancelAnimationFrame(this.poll);\n    this.poll = 0;\n  }\n\n  private readonly next = (): void => {\n    this.poll = 0;\n    if (this.lost()) return;\n\n    const result: PickResult | undefined = this.engine().pollPick();\n\n    if (!result) {\n      // The GPU is not done yet (usually a frame): asked again next frame, without drawing; given up at last\n      this.polls += 1;\n      if (this.polls < MAX_POLLS) this.poll = requestAnimationFrame(this.next);\n\n      return;\n    }\n    this.answer(result);\n  };\n}\n"]}

package/dist/map/layer-spec.d.ts

@@ -0,0 +1,42 @@
+/** A layer described by its type and options, as an application's configuration gives it, and the map adding it. */
+import type { ExtrusionOptions } from '../layers/extrusions.ts';
+import type { CircleOptions, FillOptions, LineOptions } from '../layers/features.ts';
+import type { GroundOptions, Layer, ModelOptions } from '../layers/layers.ts';
+import type { PointCloudOptions } from '../layers/pointclouds.ts';
+import type { SymbolOptions } from '../layers/symbols.ts';
+import type { GeoMap } from '../map.ts';
+import type { NetworkOptions, RasterOptions, Tiles3dOptions } from '../types.ts';
+/** 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;
+});
+/** Adds the layer a description gives with the `add…` method of its type; an unknown type throws */
+export declare const addSpec: <P = Record<string, unknown>>(map: GeoMap, spec: LayerSpec<P>) => Layer;

package/dist/map/layer-spec.js

@@ -0,0 +1,34 @@
+/** A layer described by its type and options, as an application's configuration gives it, and the map adding it. */
+/** Adds the layer a description gives with the `add…` method of its type; an unknown type throws */
+export const addSpec = (map, spec) => {
+    switch (spec.type) {
+        case 'lines':
+            return map.addLines(spec);
+        case 'circles':
+            return map.addCircles(spec);
+        case 'fills':
+            return map.addFills(spec);
+        case 'symbols':
+            return map.addSymbols(spec);
+        case 'extrusions':
+            return map.addExtrusions(spec);
+        case 'raster':
+            return map.addRaster(spec);
+        case 'ground':
+            return map.addGround(spec);
+        case 'network':
+            return map.addNetwork(spec);
+        case 'tiles3d':
+            return map.addTiles3d(spec);
+        case 'pointcloud':
+            return map.addPointCloud(spec);
+        case 'models':
+            return map.addModels(spec);
+        default: {
+            // Only from an application's configuration, untyped: the cases above cover every type
+            const { type } = spec;
+            throw new Error(`isard: no layer of type ${String(type)}`);
+        }
+    }
+};
+//# sourceMappingURL=layer-spec.js.map

package/dist/map/layer-spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"layer-spec.js","sourceRoot":"","sources":["../../src/map/layer-spec.ts"],"names":[],"mappings":"AAAA,oHAAoH;AAwBpH,oGAAoG;AACpG,MAAM,CAAC,MAAM,OAAO,GAAG,CAA8B,GAAW,EAAE,IAAkB,EAAS,EAAE;IAC7F,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QAClB,KAAK,OAAO;YACV,OAAO,GAAG,CAAC,QAAQ,CAAI,IAAI,CAAC,CAAC;QAC/B,KAAK,SAAS;YACZ,OAAO,GAAG,CAAC,UAAU,CAAI,IAAI,CAAC,CAAC;QACjC,KAAK,OAAO;YACV,OAAO,GAAG,CAAC,QAAQ,CAAI,IAAI,CAAC,CAAC;QAC/B,KAAK,SAAS;YACZ,OAAO,GAAG,CAAC,UAAU,CAAI,IAAI,CAAC,CAAC;QACjC,KAAK,YAAY;YACf,OAAO,GAAG,CAAC,aAAa,CAAI,IAAI,CAAC,CAAC;QACpC,KAAK,QAAQ;YACX,OAAO,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,KAAK,QAAQ;YACX,OAAO,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,KAAK,SAAS;YACZ,OAAO,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9B,KAAK,SAAS;YACZ,OAAO,GAAG,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;QAC9B,KAAK,YAAY;YACf,OAAO,GAAG,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;QACjC,KAAK,QAAQ;YACX,OAAO,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC;QAC7B,OAAO,CAAC,CAAC,CAAC;YACR,sFAAsF;YACtF,MAAM,EAAE,IAAI,EAAE,GAAuB,IAAI,CAAC;YAE1C,MAAM,IAAI,KAAK,CAAC,2BAA2B,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;AACH,CAAC,CAAC","sourcesContent":["/** A layer described by its type and options, as an application's configuration gives it, and the map adding it. */\n\nimport type { ExtrusionOptions } from '../layers/extrusions.ts';\nimport type { CircleOptions, FillOptions, LineOptions } from '../layers/features.ts';\nimport type { GroundOptions, Layer, ModelOptions } from '../layers/layers.ts';\nimport type { PointCloudOptions } from '../layers/pointclouds.ts';\nimport type { SymbolOptions } from '../layers/symbols.ts';\nimport type { GeoMap } from '../map.ts';\nimport type { NetworkOptions, RasterOptions, Tiles3dOptions } from '../types.ts';\n\n/** A layer by its type and the options of its `add…` method (`GeoMap.add`) */\nexport type LayerSpec<P = Record<string, unknown>> =\n  | ({ type: 'lines' } & LineOptions<P>)\n  | ({ type: 'circles' } & CircleOptions<P>)\n  | ({ type: 'fills' } & FillOptions<P>)\n  | ({ type: 'symbols' } & SymbolOptions<P>)\n  | ({ type: 'extrusions' } & ExtrusionOptions<P>)\n  | ({ type: 'raster' } & RasterOptions & { before?: Layer })\n  | ({ type: 'ground' } & GroundOptions & { before?: Layer })\n  | ({ type: 'network' } & NetworkOptions)\n  | ({ type: 'tiles3d' } & Tiles3dOptions)\n  | ({ type: 'pointcloud' } & PointCloudOptions & { before?: Layer })\n  | ({ type: 'models' } & ModelOptions & { before?: Layer });\n\n/** Adds the layer a description gives with the `add…` method of its type; an unknown type throws */\nexport const addSpec = <P = Record<string, unknown>>(map: GeoMap, spec: LayerSpec<P>): Layer => {\n  switch (spec.type) {\n    case 'lines':\n      return map.addLines<P>(spec);\n    case 'circles':\n      return map.addCircles<P>(spec);\n    case 'fills':\n      return map.addFills<P>(spec);\n    case 'symbols':\n      return map.addSymbols<P>(spec);\n    case 'extrusions':\n      return map.addExtrusions<P>(spec);\n    case 'raster':\n      return map.addRaster(spec);\n    case 'ground':\n      return map.addGround(spec);\n    case 'network':\n      return map.addNetwork(spec);\n    case 'tiles3d':\n      return map.addTiles3d(spec);\n    case 'pointcloud':\n      return map.addPointCloud(spec);\n    case 'models':\n      return map.addModels(spec);\n    default: {\n      // Only from an application's configuration, untyped: the cases above cover every type\n      const { type }: { type?: unknown } = spec;\n\n      throw new Error(`isard: no layer of type ${String(type)}`);\n    }\n  }\n};\n"]}

package/dist/map/layer-stack.d.ts

@@ -0,0 +1,36 @@
+/**
+ * The drawing order of a map's layers, kept beside the engine's: the layers waiting for the engine with 3D Tiles are
+ * in the order but not in the engine yet, and the order recreates the layers in a new engine after a context loss.
+ */
+import type { Layer } from '../layers/layers.ts';
+import type { Engine } from '../wasm/isard.js';
+/** A map's layers in drawing order, bottom first, and those kept on top */
+export declare class LayerStack {
+    /** Layers in drawing order (bottom first), to recreate them after a context loss */
+    readonly layers: Layer[];
+    /** Layers new layers go under */
+    readonly onTop: Set<Layer>;
+    private readonly engine;
+    /** `engine`: the map's engine of the moment */
+    constructor(engine: () => Engine);
+    has(layer: Layer): boolean;
+    /** Puts a new layer on top, under the layers kept on top (the basemap's labels) */
+    add(layer: Layer): void;
+    /** Forgets a removed layer */
+    forget(layer: Layer): void;
+    /** Moves a layer under `before`, or on top of all */
+    move(layer: Layer, before: Layer | undefined): void;
+    /** A layer made again in the engine under a new id: `old` removed, the new one moved to the layer's place */
+    replace(layer: Layer, old: number): void;
+    /** Moves a layer under all the others */
+    toBottom(layer: Layer): void;
+    /** Creates the layers in a new engine, in order, but those still `waiting` (for the engine with 3D Tiles); a layer
+     * that fails is reported and left out */
+    reattach(engine: Engine, waiting: (layer: Layer) => boolean): void;
+    /** Frees what the layers hold beside the engine (custom layers' WebGL objects, models' data) */
+    dispose(): void;
+    /** Takes a layer out of the drawing order (to put it back elsewhere, or for good) */
+    private unlist;
+    /** 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;
+}