@sakuzu/maplibre-gl-draw 1.0.0

package/dist/view/layer/custom-layer.js

@@ -0,0 +1,509 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+import { resolvePixelRatio } from '../../shared/utils/pixel-ratio.js';
+import { updateGlobeSubdivision } from '../globe-subdivision.js';
+import { beginRenderFrame } from '../shaders/frame.js';
+import { installAnchorProjector, uninstallAnchorProjector } from '../terrain/anchor.js';
+import { releaseTerrainContext, } from '../terrain/context.js';
+import { getCameraMercator } from '../terrain/detect.js';
+import { setQuadDrapeFrame, setTerrainCameraMoving, setTerrainRenderState, } from '../terrain/state.js';
+import { DisplayListCache } from './display-list.js';
+import { DrapePlanner } from './drape-planner.js';
+import { renderForeground, renderSegment } from './frame-render.js';
+import { buildFrameState, StyleZoom } from './frame-state.js';
+import { createRenderScope } from './render-scope.js';
+import { disposeRenderers, initRenderers } from './renderers.js';
+import { SlotManager } from './slot-manager.js';
+import { renderSlotLayerId } from './slots.js';
+import { StoreRetainedCache } from './store-retained.js';
+import { isOpacityOnlyLayersChange } from './store-retained-invalidation.js';
+import { TerrainResolver } from './terrain-resolver.js';
+/**
+ * Factory function of the CustomLayerInterface
+ *
+ * @internal
+ */
+export function createCustomLayer(deps) {
+    const { map, store, spatialIndex, featureStyle, selectionConfig, renderingConfig, customFeatureHandlers, datasets, pixelRatio, } = deps;
+    // The providers of companion drawing are dedicated to this instance
+    const featureCompanions = deps.featureCompanions;
+    // Map of the custom feature handlers
+    const customRenderers = new Map();
+    if (customFeatureHandlers) {
+        for (const handler of customFeatureHandlers) {
+            customRenderers.set(handler.type, handler.renderer);
+        }
+    }
+    const engine = {
+        gl: null,
+        mapInstance: null,
+        renderers: null,
+        storeRetainedCache: null,
+        builtPixelRatio: null,
+        unsubscribeStore: null,
+        unwatchContextLoss: null,
+        frame: null,
+        preparedTerrainState: null,
+    };
+    /** The ordered list of the features to display (the immediate path; follows the Store) */
+    const displayList = new DisplayListCache(store);
+    const dynamicOverlayRenderers = [];
+    /**
+     * Terrain state of this draw instance
+     *
+     * The frame state, the generation counters, the frame of the anchor projection and the
+     * subdivision cache are all held here. It used to be module-global, and the screen, the
+     * thumbnails, the previews and the print overwrote each other's state every frame.
+     * It is part of the render scope, together with the caches of triangulation and style
+     * evaluation that are keyed by feature id (another instance holding the same ids never reads
+     * them). The renderers receive the parts they need at construction.
+     */
+    const renderScope = createRenderScope(deps.selectionScope);
+    const terrainContext = renderScope.terrain;
+    const terrainResolver = new TerrainResolver(map, terrainContext);
+    const drape = new DrapePlanner({
+        map,
+        store,
+        terrain: terrainContext,
+        datasets,
+        timeSlicing: renderingConfig.timeSlicing,
+    });
+    const styleZoom = new StyleZoom();
+    const slots = new SlotManager({
+        map,
+        getLayerOrder: () => store.getLayerOrder(),
+        isExternalEntry: deps.isExternalEntry,
+        onSlotsChange: deps.onSlotsChange,
+        createSlotLayer: makeSlotLayer,
+    });
+    // ---------------------------------------------------------------------------
+    // Creation and disposal of the engine (built when the first slot goes onto the map, torn down
+    // when the last slot is removed)
+    // ---------------------------------------------------------------------------
+    function engineAdd(mapInstance, glContext) {
+        if (!slots.attach())
+            return;
+        engine.gl = glContext;
+        engine.mapInstance = mapInstance;
+        // Insert the anchor projection into the hit testing side. It only takes effect in the frames
+        // where the terrain is active (it returns null until setAnchorFrame is called), and on a map
+        // without terrain the project of MapLibre is used as before.
+        installAnchorProjector(mapInstance, terrainContext);
+        // Subscribe to the Store changes to invalidate the earcut, style rule and retained batch
+        // caches
+        // Changes made while the layer was off the map were not seen
+        displayList.invalidate();
+        engine.unsubscribeStore = store.subscribe((changes) => {
+            engine.storeRetainedCache?.applyChanges(changes);
+            displayList.applyChanges(changes);
+            // The binning of the analytic drape is rebuilt only on a change of the geometry, the style,
+            // the membership or the order. Rebuilding it indiscriminately on changes such as
+            // selection / editing / tentative / mode would run the dataset (about 10 ms) and the
+            // binning on every interaction and make the map stutter (measured; the exclusion test of
+            // the dataset depends only on the type and the style, so the collected result does not
+            // change even without looking at them). The opacity of a layer is a factor of its drape
+            // source, written every frame, so a change of the opacity alone keeps the binning.
+            const affectsDrape = changes.features !== undefined ||
+                (changes.layers !== undefined && !isOpacityOnlyLayersChange(changes.layers)) ||
+                changes.groups !== undefined ||
+                changes.layerReorder !== undefined ||
+                changes.groupReorder !== undefined;
+            if (affectsDrape)
+                drape.invalidate();
+            if (changes.features?.updated) {
+                for (const { id } of changes.features.updated) {
+                    renderScope.earcut.delete(id);
+                    renderScope.styleRules.delete(id);
+                    terrainContext.fillCache.delete(id);
+                }
+            }
+            if (changes.features?.deleted) {
+                for (const feature of changes.features.deleted) {
+                    renderScope.earcut.delete(feature.id);
+                    renderScope.styleRules.delete(feature.id);
+                    terrainContext.fillCache.delete(feature.id);
+                }
+            }
+            // When the style rule of a layer changes, the evaluation results of every feature that
+            // belongs to that layer go stale. There is no reverse lookup of the membership, so the
+            // whole cache is discarded (changing a rule is a rare operation).
+            if (changes.layers?.updated) {
+                for (const { layer, previous } of changes.layers.updated) {
+                    if (layer.styleRule !== previous.styleRule) {
+                        renderScope.styleRules.clear();
+                        break;
+                    }
+                }
+            }
+            // When the stacking order changes, the slots follow it (a layer added, removed or
+            // reordered; a dataset joining the order also goes through setLayerOrder
+            // and arrives here)
+            if (changes.layers !== undefined)
+                slots.sync();
+        });
+        watchContextLoss(mapInstance);
+        // Build the GPU side (skipped while the context is lost; the restore builds it then)
+        buildGpuResources();
+        // If the stacking order changed before it was added, the number of slots is matched here
+        slots.sync();
+    }
+    function engineRemove() {
+        if (!slots.detach())
+            return;
+        if (engine.unsubscribeStore) {
+            engine.unsubscribeStore();
+            engine.unsubscribeStore = null;
+        }
+        engine.unwatchContextLoss?.();
+        engine.unwatchContextLoss = null;
+        releaseGpuResources();
+        // The overlay renderers stay registered. maplibre removes the custom layers when it swaps
+        // the style or loses the WebGL context, and the host adds them back afterwards; the overlays
+        // then receive onAdd again from buildGpuResources (they were registered once, by a plugin or
+        // at creation, and nobody registers them a second time).
+        engine.mapInstance = null;
+        renderScope.earcut.clear();
+        renderScope.styleRules.clear();
+        // Release the terrain state of this instance
+        releaseTerrainContext(terrainContext);
+        // Remove the inserted anchor projection (hit testing goes back to the project of MapLibre)
+        if (map)
+            uninstallAnchorProjector(map);
+    }
+    // ---------------------------------------------------------------------------
+    // GPU resources (every buffer, texture, program, vertex array and framebuffer)
+    //
+    // Everything that lives in the WebGL context is created by buildGpuResources and dropped by
+    // releaseGpuResources, and nothing else holds a GL object across frames. A lost context
+    // invalidates every GL object at once, so this pair is also what the context loss and the
+    // restore run (docs/internals/rendering.md, "GPU resources and WebGL context loss"). The CPU-side
+    // state (the Store subscription, the caches of triangulation and style evaluation, the
+    // drape index of the elements) is kept.
+    // ---------------------------------------------------------------------------
+    /**
+     * Creates the GPU resources of the engine
+     *
+     * It does nothing when they already exist or when the context is lost (the restore calls it
+     * again).
+     */
+    function buildGpuResources() {
+        const { gl, mapInstance } = engine;
+        if (engine.renderers || !gl || !mapInstance || gl.isContextLost())
+            return;
+        engine.renderers = initRenderers({
+            gl,
+            map: mapInstance,
+            store,
+            spatialIndex,
+            featureStyle,
+            selectionConfig,
+            renderingConfig,
+            customFeatureHandlers,
+            pixelRatio,
+            scope: renderScope,
+            onImageError: deps.onImageError,
+        });
+        if (renderingConfig.storeRetained !== false) {
+            engine.storeRetainedCache = new StoreRetainedCache(store, {
+                terrain: terrainContext,
+                extensions: renderScope.selection.extensions,
+            });
+        }
+        // Initialize the custom renderers and the overlay renderers (an overlay added before the
+        // engine existed receives its onAdd here)
+        for (const renderer of customRenderers.values()) {
+            renderer.onAdd(gl, mapInstance);
+        }
+        for (const renderer of dynamicOverlayRenderers) {
+            renderer.onAdd(gl, mapInstance);
+        }
+    }
+    /**
+     * Drops the GPU resources of the engine
+     *
+     * The delete calls are harmless on a lost context (WebGL ignores them), so the same path serves
+     * the removal from the map and the context loss.
+     */
+    function releaseGpuResources() {
+        engine.frame = null;
+        engine.preparedTerrainState = null;
+        const r = engine.renderers;
+        if (!r)
+            return;
+        for (const renderer of customRenderers.values()) {
+            renderer.onRemove();
+        }
+        for (const renderer of dynamicOverlayRenderers) {
+            renderer.onRemove();
+        }
+        // Release the retained-mode GPU resources held by the datasets (the
+        // datasets themselves are kept and built again once the layer is recreated)
+        datasets?.disposeRetained();
+        // Release the retained batches of the Store rendering too (before disposing the renderers)
+        engine.storeRetainedCache?.dispose(r.batchManager.getRetainedRenderers());
+        engine.storeRetainedCache = null;
+        engine.builtPixelRatio = null;
+        // The DEM atlas, the drape renderers, and the plan and the index that point into the pack
+        // uploaded to the drape renderer (the next frame collects and uploads again)
+        terrainResolver.releaseGpu();
+        drape.releaseGpu();
+        setQuadDrapeFrame(terrainContext, null);
+        disposeRenderers(r);
+        engine.renderers = null;
+    }
+    /**
+     * Follows the loss and the restore of the WebGL context of the map
+     *
+     * These are events of the GL context, not input, so they are subscribed here and not in the
+     * InputNormalizer. maplibre 6.6 itself removes every custom layer when the context is lost
+     * (onRemove runs, and this listener goes with it) and does not add them back; the host adds
+     * them again after the restore (attachSlotLayers follows `styledata`), and onAdd builds
+     * everything again. The listener covers the other shape, where the layer stays on the map
+     * through the loss: the GPU side is dropped on the loss and built again on the restore
+     * (docs/internals/maplibre-coupling.md, item 23).
+     */
+    function watchContextLoss(mapInstance) {
+        const canvas = mapInstance.getCanvas?.();
+        if (!canvas)
+            return;
+        const onLost = () => {
+            releaseGpuResources();
+        };
+        const onRestored = () => {
+            if (slots.addedCount === 0)
+                return;
+            buildGpuResources();
+            mapInstance.triggerRepaint?.();
+        };
+        canvas.addEventListener('webglcontextlost', onLost, false);
+        canvas.addEventListener('webglcontextrestored', onRestored, false);
+        engine.unwatchContextLoss = () => {
+            canvas.removeEventListener('webglcontextlost', onLost, false);
+            canvas.removeEventListener('webglcontextrestored', onRestored, false);
+        };
+    }
+    // ---------------------------------------------------------------------------
+    // Preparation of the frame (done once by the first slot)
+    // ---------------------------------------------------------------------------
+    function beginFrame(renderOptions) {
+        const { gl, renderers: r } = engine;
+        if (!gl || !r)
+            return null;
+        // Declare the switch to a new frame (this invalidates the memoized uniforms held by each
+        // renderer; see shaders/frame.ts)
+        beginRenderFrame();
+        // While the camera is moving, the re-baking of the retained batches is deferred (read by
+        // display/chunk-set.ts)
+        setTerrainCameraMoving(terrainContext, map?.isMoving?.() === true || map?.isZooming?.() === true);
+        // The zoom that the rendering reads is the style zoom (a value that absorbs the steps of the
+        // elevation settlement; frame-state.ts). The position of the camera (the altitude in meters)
+        // tells a settlement from a jump of the camera
+        const rawZoom = map?.getZoom() ?? 14;
+        const cameraBusy = map?.isMoving?.() === true || map?.isZooming?.() === true;
+        const zoom = styleZoom.update(rawZoom, cameraBusy, getCameraMercator(map, 1));
+        // The datasets decide the rows they draw from the zoom of this frame, before anything of it
+        // is drawn (the drape plan below and every layer of the frame read the same rows)
+        datasets?.beginFrame(zoom);
+        // Detection of the terrain and establishing the frame state
+        //
+        // INACTIVE is put in place when there is no terrain. The u_terrain_on of the shaders becomes
+        // 0 and the vertex computation is exactly the same as before the terrain was introduced (zero
+        // regression). This is looked at every frame (setTerrain / removeTerrain emit no event).
+        //
+        // It is normally resolved in prerender, before maplibre starts the main pass, because baking
+        // the DEM atlas renders into a framebuffer of its own; switching framebuffers in the middle
+        // of the main pass makes a tiled GPU store and reload the whole frame
+        const terrainState = engine.preparedTerrainState ?? terrainResolver.resolve(gl);
+        engine.preparedTerrainState = null;
+        setTerrainRenderState(terrainContext, terrainState);
+        // The cells the globe cuts the geometry into (none on a flat map; globe-subdivision.ts)
+        updateGlobeSubdivision(terrainContext, renderOptions.defaultProjectionData.projectionTransition ?? 0, rawZoom);
+        // Follow the changes of the rendering pixel ratio (moving to another display, or
+        // draw.setRenderScale()). The widths of the already baked retained batches no longer match
+        // when the ratio changes, so they are discarded.
+        const dpr = resolvePixelRatio(pixelRatio);
+        if (engine.builtPixelRatio !== dpr) {
+            if (engine.builtPixelRatio !== null)
+                engine.storeRetainedCache?.invalidateAll();
+            engine.builtPixelRatio = dpr;
+        }
+        return buildFrameState({
+            gl,
+            renderers: r,
+            map,
+            store,
+            terrainContext,
+            displayList,
+            drape,
+            renderOptions,
+            zoom,
+            rawZoom,
+            dpr,
+            terrainState,
+            retainedAvailable: engine.storeRetainedCache !== null,
+            overlayRenderers: dynamicOverlayRenderers,
+            segments: slots.segments,
+        });
+    }
+    // ---------------------------------------------------------------------------
+    // render of a slot (maplibre calls it per slot)
+    // ---------------------------------------------------------------------------
+    function renderSlot(index, renderOptions) {
+        const { gl, renderers: r } = engine;
+        // Nothing is drawn while the GPU side is missing (a lost context, before the restore)
+        if (!gl || !r || gl.isContextLost())
+            return;
+        // The slots are called in the order of the list (ascending index). An index that goes back
+        // means a new frame. A frame where the last slot never arrived (right after slots were added
+        // or removed, for example) is closed here as well
+        if (engine.frame === null || index <= engine.frame.lastIndex) {
+            engine.frame = beginFrame(renderOptions);
+        }
+        const frame = engine.frame;
+        if (!frame)
+            return;
+        // Right after slots are removed, the render of a removed slot never arrives (it has been
+        // removed from the map), but to be safe nothing outside the segments is drawn
+        if (index >= frame.segments.length)
+            return;
+        const renderDeps = {
+            gl,
+            renderers: r,
+            map,
+            store,
+            terrainContext,
+            drape,
+            customRenderers,
+            featureCompanions,
+            datasets,
+            storeRetainedCache: engine.storeRetainedCache,
+            selectionScope: renderScope.selection,
+        };
+        renderSegment(renderDeps, frame, index);
+        frame.lastIndex = index;
+        if (index === frame.segments.length - 1) {
+            renderForeground(renderDeps, frame);
+            engine.frame = null;
+        }
+    }
+    /** Creates the CustomLayer of the slot at `index` (the first one is customLayer itself) */
+    function makeSlotLayer(index) {
+        return {
+            id: renderSlotLayerId(index),
+            type: 'custom',
+            renderingMode: '3d',
+            onAdd(mapInstance, glContext) {
+                engineAdd(mapInstance, glContext);
+            },
+            render(_gl, renderOptions) {
+                renderSlot(index, renderOptions);
+            },
+            onRemove() {
+                engineRemove();
+            },
+        };
+    }
+    /** Whether a feature renderer is still registered for some type */
+    function isRegisteredRenderer(renderer) {
+        for (const registered of customRenderers.values()) {
+            if (registered === renderer)
+                return true;
+        }
+        return false;
+    }
+    const customLayer = {
+        id: renderSlotLayerId(0),
+        type: 'custom',
+        renderingMode: '3d',
+        onAdd(mapInstance, glContext) {
+            engineAdd(mapInstance, glContext);
+        },
+        // The offscreen pass of maplibre, before the main pass of the frame. Only the first slot
+        // prepares here: the terrain state of the frame, which bakes the DEM atlas into its own
+        // framebuffer when the terrain changed (maplibre resets its GL state after it; see
+        // maplibre-coupling.md, "prerender")
+        prerender() {
+            const { gl } = engine;
+            if (!gl || !engine.renderers || gl.isContextLost())
+                return;
+            engine.preparedTerrainState = terrainResolver.resolve(gl);
+        },
+        // The first argument also accepts WebGL1, to match the declaration of CustomRenderMethod
+        // (what is used is the WebGL2 context received in onAdd, so the body does not change).
+        render(_gl, renderOptions) {
+            renderSlot(0, renderOptions);
+        },
+        onRemove() {
+            engineRemove();
+        },
+        addOverlayRenderer(renderer) {
+            dynamicOverlayRenderers.push(renderer);
+            // An element involved in the rendering was added, so the prepared retained batches are
+            // rebuilt
+            engine.storeRetainedCache?.invalidateAll();
+            // Only while the GPU side exists (otherwise buildGpuResources calls onAdd)
+            if (engine.renderers && engine.gl && engine.mapInstance) {
+                renderer.onAdd(engine.gl, engine.mapInstance);
+            }
+            return () => customLayer.removeOverlayRenderer(renderer);
+        },
+        removeOverlayRenderer(renderer) {
+            const index = dynamicOverlayRenderers.indexOf(renderer);
+            if (index === -1)
+                return;
+            dynamicOverlayRenderers.splice(index, 1);
+            engine.storeRetainedCache?.invalidateAll();
+            // Its GPU resources exist only while the engine does
+            if (engine.renderers && engine.gl)
+                renderer.onRemove();
+            engine.mapInstance?.triggerRepaint();
+        },
+        registerFeatureRenderer(type, renderer) {
+            const replaced = customRenderers.get(type);
+            customRenderers.set(type, renderer);
+            // Adding a custom type changes the classification of the features (whether they can be
+            // retained)
+            engine.storeRetainedCache?.invalidateAll();
+            // Only while the GPU side exists (otherwise buildGpuResources calls onAdd)
+            if (engine.renderers && engine.gl && engine.mapInstance) {
+                // A renderer can serve several types: it is released only when no type uses it
+                if (replaced && !isRegisteredRenderer(replaced))
+                    replaced.onRemove();
+                renderer.onAdd(engine.gl, engine.mapInstance);
+            }
+            return () => {
+                if (customRenderers.get(type) !== renderer)
+                    return;
+                customRenderers.delete(type);
+                engine.storeRetainedCache?.invalidateAll();
+                if (engine.renderers && engine.gl && !isRegisteredRenderer(renderer))
+                    renderer.onRemove();
+                engine.mapInstance?.triggerRepaint();
+            };
+        },
+        getRenderSlots() {
+            return slots.getRenderSlots();
+        },
+        getSlotLayers() {
+            return slots.getSlotLayers();
+        },
+        getTerrainContext() {
+            return terrainContext;
+        },
+        hasPendingWork() {
+            if (drape.hasPendingWork)
+                return true;
+            if (datasets?.hasPendingWork())
+                return true;
+            for (const renderer of dynamicOverlayRenderers) {
+                if (renderer.hasPendingWork?.())
+                    return true;
+            }
+            return false;
+        },
+    };
+    // The first slot is customLayer itself. When there are separators, the following slots are
+    // prepared here (the host adds them to the map in order from the first)
+    slots.init(customLayer);
+    return customLayer;
+}

package/dist/view/layer/depth-state.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Switch the depth test and record the new state
+ */
+export declare function setDepthTestEnabled(gl: WebGL2RenderingContext, enabled: boolean): void;
+/**
+ * The recorded state of the depth test of a context (false when nothing was recorded yet)
+ */
+export declare function isDepthTestEnabled(gl: WebGL2RenderingContext): boolean;
+/**
+ * Sync back to the actual GL state (once at the start of a frame)
+ *
+ * This is the only place that asks GL. It happens once per frame, so the cost is negligible.
+ */
+export declare function syncDepthTestEnabled(gl: WebGL2RenderingContext): void;

package/dist/view/layer/depth-state.js

@@ -0,0 +1,44 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * Remembering the state of the depth test
+ *
+ * Symbols (point billboards and SDF glyphs) must not be clipped by the depth of the terrain, so
+ * the depth test is disabled while they are drawn and then restored
+ * (`renderers/point/billboard-depth.ts`). That "restored" value must not be obtained by asking
+ * `gl.isEnabled` every time. A WebGL state query synchronously round-trips to the GPU process, so
+ * on a map with thousands of labels it becomes thousands of round-trips in a single frame and
+ * rendering stalls for tens of seconds.
+ *
+ * Only CustomLayer and the analysis drape switch the depth test. The side that switches it records
+ * the value here, and the symbol side reads that record. The record belongs to the WebGL context
+ * whose state it mirrors (one entry per context), so two maps never read each other's value, and
+ * two draw instances on one map share the context's true state. CustomLayer also reads the actual
+ * state once at the start of a frame and syncs to it.
+ */
+/** The recorded depth test state of each WebGL context */
+const depthTestState = new WeakMap();
+/**
+ * Switch the depth test and record the new state
+ */
+export function setDepthTestEnabled(gl, enabled) {
+    if (enabled)
+        gl.enable(gl.DEPTH_TEST);
+    else
+        gl.disable(gl.DEPTH_TEST);
+    depthTestState.set(gl, enabled);
+}
+/**
+ * The recorded state of the depth test of a context (false when nothing was recorded yet)
+ */
+export function isDepthTestEnabled(gl) {
+    return depthTestState.get(gl) === true;
+}
+/**
+ * Sync back to the actual GL state (once at the start of a frame)
+ *
+ * This is the only place that asks GL. It happens once per frame, so the cost is negligible.
+ */
+export function syncDepthTestEnabled(gl) {
+    depthTestState.set(gl, gl.isEnabled(gl.DEPTH_TEST));
+}

package/dist/view/layer/display-list.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/view/layer/display-list.js

@@ -0,0 +1,111 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+/**
+ * The display list of the immediate path
+ *
+ * The immediate path draws the features in view in draw order every frame. Building that list
+ * from the Store each frame (the ordered list, the local visibility, then the viewport) walks
+ * every feature and allocates arrays of that size, which costs milliseconds on a store of 100k
+ * features even when a handful are on screen.
+ *
+ * The ordered list of the features to display depends only on the Store, so it is kept here and
+ * rebuilt only after a change that can alter it. The features in view are then taken from the
+ * spatial index (the ids inside the view) and put in draw order by their rank in the list, which
+ * costs in proportion to what is on screen rather than to the whole store.
+ */
+import { getDisplayFeatures } from '../../store/local-visibility.js';
+/**
+ * Above this share of the list, the ids in view are taken by walking the list (sorting that
+ * many ranks would cost more than one pass over the list)
+ */
+const SORT_SHARE_LIMIT = 0.25;
+/**
+ * The ordered list of the features to display, rebuilt only when the Store changes it
+ *
+ * @internal
+ */
+export class DisplayListCache {
+    constructor(store) {
+        Object.defineProperty(this, "store", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "list", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        /** featureId → position in the list (built when first needed) */
+        Object.defineProperty(this, "rank", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.store = store;
+    }
+    /** The features to display, in draw order (the same list as getDisplayFeatures) */
+    features() {
+        if (!this.list)
+            this.list = getDisplayFeatures(this.store);
+        return this.list;
+    }
+    /**
+     * The features among `ids` that are displayed, in draw order
+     *
+     * @param ids The ids to keep (the features inside the view)
+     */
+    inOrder(ids) {
+        const list = this.features();
+        if (ids.size > list.length * SORT_SHARE_LIMIT) {
+            return list.filter((feature) => ids.has(feature.id));
+        }
+        const rank = this.rankOf(list);
+        const positions = new Int32Array(ids.size);
+        let count = 0;
+        for (const id of ids) {
+            const position = rank.get(id);
+            if (position !== undefined)
+                positions[count++] = position;
+        }
+        const sorted = positions.subarray(0, count).sort();
+        const result = new Array(count);
+        for (let i = 0; i < count; i++)
+            result[i] = list[sorted[i]];
+        return result;
+    }
+    /**
+     * Follows a change of the Store
+     *
+     * The list depends on the features (their visibility and membership), the layers, the groups,
+     * their order and the local visibility (reported as a change of the UI state). A change of the
+     * selection alone, for example, keeps it.
+     */
+    applyChanges(changes) {
+        if (changes.features !== undefined ||
+            changes.layers !== undefined ||
+            changes.groups !== undefined ||
+            changes.layerReorder !== undefined ||
+            changes.groupReorder !== undefined ||
+            changes.uiStateChanged === true) {
+            this.invalidate();
+        }
+    }
+    /** Forgets the list (the next use rebuilds it) */
+    invalidate() {
+        this.list = null;
+        this.rank = null;
+    }
+    rankOf(list) {
+        if (!this.rank) {
+            const rank = new Map();
+            for (let i = 0; i < list.length; i++)
+                rank.set(list[i].id, i);
+            this.rank = rank;
+        }
+        return this.rank;
+    }
+}