isard 1.0.0 → 1.2.0

package/dist/map/frame-loop.js

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

package/dist/map/layer-stack.js

@@ -0,0 +1,101 @@
+/**
+ * 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 { report } from "./checks.js";
+/** A map's layers in drawing order, bottom first, and those kept on top */
+export class LayerStack {
+    /** Layers in drawing order (bottom first), to recreate them after a context loss */
+    layers = [];
+    /** Layers new layers go under */
+    onTop = new Set();
+    engine;
+    /** `engine`: the map's engine of the moment */
+    constructor(engine) {
+        this.engine = engine;
+    }
+    has(layer) {
+        return this.layers.includes(layer);
+    }
+    /** Puts a new layer on top, under the layers kept on top (the basemap's labels) */
+    add(layer) {
+        this.layers.push(layer);
+        const top = this.layers.find((l) => this.onTop.has(l) && l !== layer);
+        if (top)
+            this.move(layer, top);
+    }
+    /** Forgets a removed layer */
+    forget(layer) {
+        this.unlist(layer);
+        this.onTop.delete(layer);
+    }
+    /** Moves a layer under `before`, or on top of all */
+    move(layer, before) {
+        this.unlist(layer);
+        const index = before ? this.layers.indexOf(before) : -1;
+        const at = index < 0 ? this.layers.length : index;
+        this.layers.splice(at, 0, layer);
+        if (layer.id >= 0)
+            this.engine().moveLayer(layer.id, this.engineIndex(at));
+    }
+    /** A layer made again in the engine under a new id: `old` removed, the new one moved to the layer's place */
+    replace(layer, old) {
+        const engine = this.engine();
+        engine.removeLayer(old);
+        const index = this.layers.indexOf(layer);
+        if (index >= 0)
+            engine.moveLayer(layer.id, this.engineIndex(index));
+    }
+    /** Moves a layer under all the others */
+    toBottom(layer) {
+        this.engine().moveLayer(layer.id, 0);
+        this.unlist(layer);
+        this.layers.unshift(layer);
+    }
+    /** 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, waiting) {
+        // No layer refers to an id of the old engine while the others are created
+        this.layers.forEach((layer) => {
+            layer.forgetEngine();
+        });
+        this.layers.forEach((layer) => {
+            if (waiting(layer))
+                return;
+            try {
+                layer.attach(engine);
+            }
+            catch (error) {
+                report(error);
+            }
+        });
+        // Links between layers, once every layer has its new id (buildings colored by a network above them)
+        this.layers.forEach((layer) => {
+            if (layer.id < 0)
+                return;
+            try {
+                layer.relink(engine);
+            }
+            catch (error) {
+                report(error);
+            }
+        });
+    }
+    /** Frees what the layers hold beside the engine (custom layers' WebGL objects, models' data) */
+    dispose() {
+        this.layers.forEach((layer) => {
+            layer.dispose();
+        });
+    }
+    /** Takes a layer out of the drawing order (to put it back elsewhere, or for good) */
+    unlist(layer) {
+        const index = this.layers.indexOf(layer);
+        if (index >= 0)
+            this.layers.splice(index, 1);
+    }
+    /** Index in the engine of the layer at `index`: the layers waiting for the engine with 3D Tiles are not in it yet */
+    engineIndex(index) {
+        return this.layers.slice(0, index).filter((layer) => layer.id >= 0).length;
+    }
+}
+//# sourceMappingURL=layer-stack.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"layer-stack.js","sourceRoot":"","sources":["../../src/map/layer-stack.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * The drawing order of a map's layers, kept beside the engine's: the layers waiting for the engine with 3D Tiles are\n * in the order but not in the engine yet, and the order recreates the layers in a new engine after a context loss.\n */\n\nimport type { Layer } from '../layers/layers.ts';\nimport type { Engine } from '../wasm/isard.js';\nimport { report } from './checks.ts';\n\n/** A map's layers in drawing order, bottom first, and those kept on top */\nexport class LayerStack {\n  /** Layers in drawing order (bottom first), to recreate them after a context loss */\n  readonly layers: Layer[] = [];\n  /** Layers new layers go under */\n  readonly onTop = new Set<Layer>();\n  private readonly engine: () => Engine;\n\n  /** `engine`: the map's engine of the moment */\n  constructor(engine: () => Engine) {\n    this.engine = engine;\n  }\n\n  has(layer: Layer): boolean {\n    return this.layers.includes(layer);\n  }\n\n  /** Puts a new layer on top, under the layers kept on top (the basemap's labels) */\n  add(layer: Layer): void {\n    this.layers.push(layer);\n\n    const top = this.layers.find((l) => this.onTop.has(l) && l !== layer);\n\n    if (top) this.move(layer, top);\n  }\n\n  /** Forgets a removed layer */\n  forget(layer: Layer): void {\n    this.unlist(layer);\n    this.onTop.delete(layer);\n  }\n\n  /** Moves a layer under `before`, or on top of all */\n  move(layer: Layer, before: Layer | undefined): void {\n    this.unlist(layer);\n\n    const index = before ? this.layers.indexOf(before) : -1;\n    const at = index < 0 ? this.layers.length : index;\n\n    this.layers.splice(at, 0, layer);\n    if (layer.id >= 0) this.engine().moveLayer(layer.id, this.engineIndex(at));\n  }\n\n  /** A layer made again in the engine under a new id: `old` removed, the new one moved to the layer's place */\n  replace(layer: Layer, old: number): void {\n    const engine = this.engine();\n\n    engine.removeLayer(old);\n\n    const index = this.layers.indexOf(layer);\n\n    if (index >= 0) engine.moveLayer(layer.id, this.engineIndex(index));\n  }\n\n  /** Moves a layer under all the others */\n  toBottom(layer: Layer): void {\n    this.engine().moveLayer(layer.id, 0);\n    this.unlist(layer);\n    this.layers.unshift(layer);\n  }\n\n  /** Creates the layers in a new engine, in order, but those still `waiting` (for the engine with 3D Tiles); a layer\n   * that fails is reported and left out */\n  reattach(engine: Engine, waiting: (layer: Layer) => boolean): void {\n    // No layer refers to an id of the old engine while the others are created\n    this.layers.forEach((layer) => {\n      layer.forgetEngine();\n    });\n    this.layers.forEach((layer) => {\n      if (waiting(layer)) return;\n      try {\n        layer.attach(engine);\n      } catch (error) {\n        report(error);\n      }\n    });\n    // Links between layers, once every layer has its new id (buildings colored by a network above them)\n    this.layers.forEach((layer) => {\n      if (layer.id < 0) return;\n      try {\n        layer.relink(engine);\n      } catch (error) {\n        report(error);\n      }\n    });\n  }\n\n  /** Frees what the layers hold beside the engine (custom layers' WebGL objects, models' data) */\n  dispose(): void {\n    this.layers.forEach((layer) => {\n      layer.dispose();\n    });\n  }\n\n  /** Takes a layer out of the drawing order (to put it back elsewhere, or for good) */\n  private unlist(layer: Layer): void {\n    const index = this.layers.indexOf(layer);\n\n    if (index >= 0) this.layers.splice(index, 1);\n  }\n\n  /** Index in the engine of the layer at `index`: the layers waiting for the engine with 3D Tiles are not in it yet */\n  private engineIndex(index: number): number {\n    return this.layers.slice(0, index).filter((layer) => layer.id >= 0).length;\n  }\n}\n"]}

package/dist/map/overlay-host.d.ts

@@ -0,0 +1,36 @@
+/**
+ * What the map shows over its canvas, in its container: the markers and popups (placed after every frame) and the
+ * controls in the four corners.
+ */
+import type { GeoMap } from '../map.ts';
+import type { Point } from '../types.ts';
+import type { Control, ControlPosition } from '../ui/controls.ts';
+import type { Positioned } from '../ui/overlay.ts';
+/** The map's container: its canvas, the element of the markers and popups over it, the corners of the controls */
+export declare class OverlayHost {
+    /** Canvas size in CSS pixels, kept on resize so placing overlays never reads the layout */
+    size: Point;
+    private readonly container;
+    private readonly canvas;
+    /** The map the controls are added to */
+    private readonly map;
+    /** Markers and popups, over the canvas */
+    private readonly overlay;
+    private readonly corners;
+    private readonly controls;
+    private readonly positioned;
+    /** Puts the canvas, the overlay and the corners in `container` */
+    constructor(container: HTMLElement, canvas: HTMLCanvasElement, map: GeoMap);
+    /** Adds a control in a corner; controls stack from the corner inward */
+    addControl(control: Control, position: ControlPosition): void;
+    removeControl(control: Control): void;
+    /** Shows a marker or popup, placed after every frame from now on */
+    attach(item: Positioned, element: HTMLElement): void;
+    detach(item: Positioned, element: HTMLElement): void;
+    /** Places one overlay now (it moved) */
+    position(item: Positioned): void;
+    /** Places every overlay for the frame just drawn (camera, relief altitudes): all in one pass, transforms only */
+    positionAll(): void;
+    /** Removes the controls, then the canvas, the overlay and the corners from the container */
+    destroy(): void;
+}

package/dist/map/overlay-host.js

@@ -0,0 +1,101 @@
+/**
+ * What the map shows over its canvas, in its container: the markers and popups (placed after every frame) and the
+ * controls in the four corners.
+ */
+import { injectStyle } from "../ui/style.js";
+const CORNERS = ['top-left', 'top-right', 'bottom-left', 'bottom-right'];
+/** The map's container: its canvas, the element of the markers and popups over it, the corners of the controls */
+export class OverlayHost {
+    /** Canvas size in CSS pixels, kept on resize so placing overlays never reads the layout */
+    size = [0, 0];
+    container;
+    canvas;
+    /** The map the controls are added to */
+    map;
+    /** Markers and popups, over the canvas */
+    overlay;
+    corners;
+    controls = new Map();
+    positioned = new Set();
+    /** Puts the canvas, the overlay and the corners in `container` */
+    constructor(container, canvas, map) {
+        this.container = container;
+        this.canvas = canvas;
+        this.map = map;
+        // Overlays and controls are positioned against the container
+        injectStyle(container.ownerDocument);
+        if (getComputedStyle(container).position === 'static')
+            container.style.position = 'relative';
+        container.classList.add('isard-map');
+        this.overlay = document.createElement('div');
+        this.overlay.className = 'isard-overlay';
+        const corner = (position) => {
+            const element = document.createElement('div');
+            element.className = `isard-ctrl-${position}`;
+            return element;
+        };
+        this.corners = {
+            'top-left': corner('top-left'),
+            'top-right': corner('top-right'),
+            'bottom-left': corner('bottom-left'),
+            'bottom-right': corner('bottom-right'),
+        };
+        container.append(canvas, this.overlay, ...CORNERS.map((position) => this.corners[position]));
+    }
+    /** Adds a control in a corner; controls stack from the corner inward */
+    addControl(control, position) {
+        if (this.controls.has(control))
+            return;
+        const element = control.onAdd(this.map);
+        element.classList.add('isard-ctrl');
+        // In the bottom corners the first control added stays lowest, as in MapLibre
+        if (position.startsWith('bottom'))
+            this.corners[position].prepend(element);
+        else
+            this.corners[position].append(element);
+        this.controls.set(control, element);
+    }
+    removeControl(control) {
+        const element = this.controls.get(control);
+        if (!element)
+            return;
+        this.controls.delete(control);
+        control.onRemove(this.map);
+        element.remove();
+    }
+    /** Shows a marker or popup, placed after every frame from now on */
+    attach(item, element) {
+        this.overlay.append(element);
+        this.positioned.add(item);
+        item.position(this.size);
+    }
+    detach(item, element) {
+        this.positioned.delete(item);
+        element.remove();
+    }
+    /** Places one overlay now (it moved) */
+    position(item) {
+        if (this.positioned.has(item))
+            item.position(this.size);
+    }
+    /** Places every overlay for the frame just drawn (camera, relief altitudes): all in one pass, transforms only */
+    positionAll() {
+        this.positioned.forEach((item) => {
+            item.position(this.size);
+        });
+    }
+    /** Removes the controls, then the canvas, the overlay and the corners from the container */
+    destroy() {
+        [...this.controls.keys()].forEach((control) => {
+            this.removeControl(control);
+        });
+        this.positioned.clear();
+        this.canvas.remove();
+        this.overlay.remove();
+        CORNERS.forEach((position) => {
+            this.corners[position].remove();
+        });
+        this.container.classList.remove('isard-map');
+    }
+}
+//# sourceMappingURL=overlay-host.js.map