@sakuzu/maplibre-gl-draw 1.0.0 → 2.1.0

package/dist/view/layer/attach.js

@@ -12,18 +12,81 @@ function styleAcceptsLayers(map) {
     return map.style?._loaded === true;
 }
 /**
- * Keeps the render slots of Draw on the map for as long as the returned detach function has not
+ * Puts the slots back on top of the map after a style change
+ *
+ * The slots, and the native layers the host placed between them (the separators), form one
+ * block that belongs at the top of the map, with the slots in their order (the first is the
+ * backmost). A full `setStyle` gives that by itself: the old layers are gone and the slots are
+ * added again on top. A diffed `setStyle` does not: maplibre's `Style.serialize()` leaves custom
+ * layers out, so the diff neither removes nor adds the slots, and the layers of the new style are
+ * added above them, which hides the drawing under the basemap.
+ *
+ * Nothing is moved when the block is already in place, so the `styledata` that follows a move
+ * finds nothing to do. When it is not, the block is moved to the top: each slot, followed by the
+ * native layers that sat just above it (up to the next slot), keeps its neighbours. The layers
+ * above the frontmost slot are taken as part of the new style and stay below the block.
+ *
+ * @param map The map
+ * @param slotLayers The slots (first = backmost)
+ */
+function placeSlotsOnTop(map, slotLayers) {
+    const order = map.getLayersOrder();
+    const slotIds = slotLayers.map((layer) => layer.id).filter((id) => order.includes(id));
+    if (slotIds.length === 0)
+        return;
+    const isSlot = new Set(slotIds);
+    // The block runs from the backmost slot on the map to the frontmost one
+    let first = -1;
+    let last = -1;
+    order.forEach((id, index) => {
+        if (!isSlot.has(id))
+            return;
+        if (first < 0)
+            first = index;
+        last = index;
+    });
+    const block = order.slice(first, last + 1);
+    const slotsInBlock = block.filter((id) => isSlot.has(id));
+    const inOrder = slotsInBlock.every((id, index) => id === slotIds[index]);
+    if (inOrder && last === order.length - 1)
+        return;
+    // Each slot keeps the native layers that followed it
+    const following = new Map();
+    let current = '';
+    for (const id of block) {
+        if (isSlot.has(id)) {
+            current = id;
+            following.set(id, []);
+        }
+        else {
+            following.get(current)?.push(id);
+        }
+    }
+    for (const slotId of slotIds) {
+        map.moveLayer(slotId);
+        for (const id of following.get(slotId) ?? [])
+            map.moveLayer(id);
+    }
+}
+/**
+ * Keeps the frames of the stacking order on the map for as long as the returned detach function has not
  * been called
  *
  * One rule covers every timing: the slots are added whenever the style accepts layers and a slot
  * is missing. It is checked once now (for a map whose style is already parsed, even while tiles
- * are still loading) and again on every `styledata` event. maplibre fires `styledata` when a
- * style finishes loading (before `style.load` and `load`) and after changes to the style, so the
- * slots are also restored after `setStyle`, including a diffed `setStyle` that drops layers it
- * does not know. A slot that is already on the map is never added twice.
+ * are still loading) and again on every `styledata` and `style.load` event. maplibre fires
+ * `styledata` when a style finishes loading (before `style.load` and `load`) and after changes to
+ * the style, so the slots are also restored after a full `setStyle`. A slot that is already on
+ * the map is never added twice.
  *
  * The slots are added in order from the first (the backmost), which lines them up in the same
- * order in maplibre (layers added later are on top).
+ * order in maplibre (layers added later are on top). A slot missing while a later one is on the
+ * map is added just behind it.
+ *
+ * On `style.load` the slots are also put back on top of the map (see `placeSlotsOnTop`). maplibre
+ * fires it when a style is loaded and at the end of a diffed `setStyle` that changed something,
+ * and only then: a layer the host adds or moves itself fires `styledata` alone, so a layer the
+ * host put above the drawing stays there until the style is changed.
  *
  * @param map The map
  * @param getSlotLayers Returns the current list of slots (first = backmost)
@@ -33,15 +96,28 @@ export function attachSlotLayers(map, getSlotLayers) {
     const ensureSlots = () => {
         if (!styleAcceptsLayers(map))
             return;
-        for (const slotLayer of getSlotLayers()) {
-            if (!map.getLayer(slotLayer.id)) {
+        const slotLayers = getSlotLayers();
+        slotLayers.forEach((slotLayer, index) => {
+            if (map.getLayer(slotLayer.id))
+                return;
+            // Behind the next slot that is on the map, so that the slots stay in order
+            const next = slotLayers.slice(index + 1).find((later) => map.getLayer(later.id));
+            if (next)
+                map.addLayer(slotLayer, next.id);
+            else
                 map.addLayer(slotLayer);
-            }
-        }
+        });
+    };
+    const restoreSlots = () => {
+        ensureSlots();
+        if (styleAcceptsLayers(map))
+            placeSlotsOnTop(map, getSlotLayers());
     };
     map.on('styledata', ensureSlots);
+    map.on('style.load', restoreSlots);
     ensureSlots();
     return () => {
         map.off('styledata', ensureSlots);
+        map.off('style.load', restoreSlots);
     };
 }

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

@@ -14,7 +14,7 @@ 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 { slotLayerId } from './slots.js';
 import { StoreRetainedCache } from './store-retained.js';
 import { isOpacityOnlyLayersChange } from './store-retained-invalidation.js';
 import { TerrainResolver } from './terrain-resolver.js';
@@ -66,7 +66,10 @@ export function createCustomLayer(deps) {
         store,
         terrain: terrainContext,
         datasets,
-        timeSlicing: renderingConfig.timeSlicing,
+        // Read at each build, so a change of the rendering switches applies to the next one
+        get timeSlicing() {
+            return renderingConfig.timeSlicing;
+        },
     });
     const styleZoom = new StyleZoom();
     const slots = new SlotManager({
@@ -94,6 +97,14 @@ export function createCustomLayer(deps) {
         // Changes made while the layer was off the map were not seen
         displayList.invalidate();
         engine.unsubscribeStore = store.subscribe((changes) => {
+            // A replacement of the whole document drops every cache of the features, whatever the
+            // notification lists (the new document can reuse an ID with another shape)
+            if (changes.reset === true) {
+                renderScope.earcut.clear();
+                renderScope.styleRules.clear();
+                terrainContext.fillCache.clear();
+                engine.storeRetainedCache?.invalidateAll();
+            }
             engine.storeRetainedCache?.applyChanges(changes);
             displayList.applyChanges(changes);
             // The binning of the analytic drape is rebuilt only on a change of the geometry, the style,
@@ -293,7 +304,7 @@ export function createCustomLayer(deps) {
         // 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)
+        // dataset/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)
@@ -319,7 +330,7 @@ export function createCustomLayer(deps) {
         // 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
+        // draw.setScaleFactor()). 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) {
@@ -389,7 +400,7 @@ export function createCustomLayer(deps) {
     /** Creates the CustomLayer of the slot at `index` (the first one is customLayer itself) */
     function makeSlotLayer(index) {
         return {
-            id: renderSlotLayerId(index),
+            id: slotLayerId(index),
             type: 'custom',
             renderingMode: '3d',
             onAdd(mapInstance, glContext) {
@@ -412,7 +423,7 @@ export function createCustomLayer(deps) {
         return false;
     }
     const customLayer = {
-        id: renderSlotLayerId(0),
+        id: slotLayerId(0),
         type: 'custom',
         renderingMode: '3d',
         onAdd(mapInstance, glContext) {
@@ -436,7 +447,7 @@ export function createCustomLayer(deps) {
         onRemove() {
             engineRemove();
         },
-        addOverlayRenderer(renderer) {
+        addOverlay(renderer) {
             dynamicOverlayRenderers.push(renderer);
             // An element involved in the rendering was added, so the prepared retained batches are
             // rebuilt
@@ -445,9 +456,9 @@ export function createCustomLayer(deps) {
             if (engine.renderers && engine.gl && engine.mapInstance) {
                 renderer.onAdd(engine.gl, engine.mapInstance);
             }
-            return () => customLayer.removeOverlayRenderer(renderer);
+            return () => customLayer.removeOverlay(renderer);
         },
-        removeOverlayRenderer(renderer) {
+        removeOverlay(renderer) {
             const index = dynamicOverlayRenderers.indexOf(renderer);
             if (index === -1)
                 return;
@@ -481,8 +492,8 @@ export function createCustomLayer(deps) {
                 engine.mapInstance?.triggerRepaint();
             };
         },
-        getRenderSlots() {
-            return slots.getRenderSlots();
+        getStackSlots() {
+            return slots.getStackSlots();
         },
         getSlotLayers() {
             return slots.getSlotLayers();
@@ -490,6 +501,9 @@ export function createCustomLayer(deps) {
         getTerrainContext() {
             return terrainContext;
         },
+        getGL() {
+            return engine.renderers ? engine.gl : null;
+        },
         hasPendingWork() {
             if (drape.hasPendingWork)
                 return true;
@@ -501,6 +515,21 @@ export function createCustomLayer(deps) {
             }
             return false;
         },
+        refresh() {
+            renderScope.earcut.clear();
+            renderScope.styleRules.clear();
+            displayList.invalidate();
+            drape.invalidate();
+            if (!engine.mapInstance)
+                return;
+            // The renderers and the retained batches read the configuration when they are built
+            if (engine.renderers) {
+                releaseGpuResources();
+                buildGpuResources();
+            }
+            slots.sync();
+            engine.mapInstance.triggerRepaint();
+        },
     };
     // 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)

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

@@ -90,7 +90,8 @@ export class DisplayListCache {
             changes.groups !== undefined ||
             changes.layerReorder !== undefined ||
             changes.groupReorder !== undefined ||
-            changes.uiStateChanged === true) {
+            changes.uiStateChanged === true ||
+            changes.reset === true) {
             this.invalidate();
         }
     }

package/dist/view/layer/drape-planner.d.ts

@@ -92,8 +92,8 @@ export interface DrapePlannerDataset extends DrapeDatasetSource {
 /**
  * The datasets as the planner sees them
  *
- * The manager in `display/manager.ts` satisfies this shape. Only the structure is declared here,
- * so that the planner does not read a type from display/ (which sits above view/).
+ * The manager in `dataset/manager.ts` satisfies this shape. Only the structure is declared here,
+ * so that the planner does not read a type from dataset/ (which sits above view/).
  */
 export interface DrapePlannerDatasets {
     listInternal(): readonly DrapePlannerDataset[];

package/dist/view/layer/frame-render.d.ts

@@ -8,7 +8,7 @@
  * set and restored through gl-state.ts.
  */
 import type { Map as MapLibreMap } from 'maplibre-gl';
-import type { CustomFeatureHandler } from '../../extension/index.js';
+import type { FeatureTypeHandler } from '../../extension/index.js';
 import type { Store } from '../../store/store.js';
 import type { FeatureCompanionRegistry } from '../feature-companion.js';
 import type { TerrainContext } from '../terrain/context.js';
@@ -20,7 +20,7 @@ import type { Renderers } from './renderers.js';
 import type { StoreRetainedCache } from './store-retained.js';
 /**
  * The datasets as the per-layer rendering takes them (the type is owned by
- * render.ts, so this file does not read a type from display/)
+ * render.ts, so this file does not read a type from dataset/)
  */
 type RenderedDatasets = Parameters<typeof renderLayers>[10];
 /** What the drawing of a frame reads (the engine of the layer, while its GPU side exists) */
@@ -31,7 +31,7 @@ export interface FrameRenderDeps {
     store: Store;
     terrainContext: TerrainContext;
     drape: DrapePlanner;
-    customRenderers: Map<string, CustomFeatureHandler['renderer']>;
+    customRenderers: Map<string, FeatureTypeHandler['renderer']>;
     featureCompanions: FeatureCompanionRegistry;
     datasets?: RenderedDatasets;
     storeRetainedCache: StoreRetainedCache | null;

package/dist/view/layer/frame-render.js

@@ -2,7 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 import { isInteractionBlocked } from '../../store/lock.js';
 import { setDrapePaintedDatasets, setQuadDrapeFrame, setTerrainRenderState, setTerrainShadeLight, setTerrainSurfacesFlattened, } from '../terrain/state.js';
-import { renderFollowedVertices, renderSelectionUI } from '../ui/selection-ui-drawer.js';
+import { renderFollowedVertices, renderGlobalAuxiliaryHandles, renderSelectionUI, } from '../ui/selection-ui-drawer.js';
 import { applyDrapeGlState, applySegmentDepthState, applySegmentGlState, enterSymbolGlState, restoreSegmentGlState, resumeDrapeGlState, } from './gl-state.js';
 import { renderLayers } from './render.js';
 /** Makes the renderers draw on one copy of the world */
@@ -156,11 +156,16 @@ export function renderForeground(deps, f) {
     };
     const tentative = store.getTentative();
     const boxSelection = store.getBoxSelection();
+    const globalHandlesShown = store.getMode() === 'select' && !store.isReadOnly() && !store.isInteractionLocked();
     // Once per copy of the world in view (the selection UI of a feature on the other side of the
     // antimeridian is drawn on the copy the feature is drawn on)
     for (const copy of f.copies) {
         applyCopy(deps, copy);
-        renderSelectionUI(copy.selectedFeatures, f.zoom, copy.projectionData, selectionUIDeps, store.getDragState(), store.getSelectedVertices(), selectionLocked);
+        renderSelectionUI(copy.selectedFeatures, f.zoom, copy.projectionData, selectionUIDeps, store.getDragState(), store.getVertexSelection(), selectionLocked);
+        // The handles of the extensions that belong to no feature, while they can be grabbed
+        if (globalHandlesShown) {
+            renderGlobalAuxiliaryHandles(f.zoom, copy.projectionData, selectionUIDeps, store.getDragState());
+        }
         // The vertices that follow along when a shared vertex is moved (raised only during a
         // drag). The features that follow are not selected, so they are drawn separately from the
         // selection UI.

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

@@ -8,7 +8,7 @@
  * drawing of the slots is in frame-render.ts.
  */
 import type { CustomRenderMethodInput, Map as MapLibreMap } from 'maplibre-gl';
-import type { CustomOverlayRenderer, CustomRendererDrawContext, LayerAwareOverlayRenderer } from '../../extension/index.js';
+import type { EngineOverlayRenderer, FrameDrawContext, LayeredOverlayRenderer } from '../../extension/index.js';
 import type { Store } from '../../store/store.js';
 import type { Feature } from '../../store/types.js';
 import { type OffsetUniforms } from '../shaders/helpers.js';
@@ -37,7 +37,7 @@ export interface CopyPass {
     readonly view: RenderLayersView | undefined;
     readonly projectionData: CustomRenderMethodInput['defaultProjectionData'];
     readonly offsetUniforms: OffsetUniforms;
-    readonly customRendererContext: CustomRendererDrawContext;
+    readonly customRendererContext: FrameDrawContext;
     /** The features drawn in immediate mode on this copy */
     readonly features: Feature[];
     /** The selected features whose selection UI is drawn on this copy */
@@ -72,9 +72,9 @@ export interface FrameState {
     readonly features: Feature[];
     readonly selectedIdSet: Set<string>;
     readonly selectedFeatures: Feature[];
-    readonly customRendererContext: CustomRendererDrawContext;
-    readonly layerAwareRenderers: LayerAwareOverlayRenderer[];
-    readonly otherRenderers: CustomOverlayRenderer[];
+    readonly customRendererContext: FrameDrawContext;
+    readonly layerAwareRenderers: LayeredOverlayRenderer[];
+    readonly otherRenderers: EngineOverlayRenderer[];
     readonly quadDrapeFrame: QuadDrapeFrame | null;
     readonly restoreBlendState: () => void;
     /** Whether the drape can be drawn (the shaders and the plan are ready) */
@@ -116,7 +116,7 @@ export interface FrameBuildInput {
     terrainState: TerrainRenderState;
     /** Whether the retained batches of the Store rendering exist */
     retainedAvailable: boolean;
-    overlayRenderers: readonly CustomOverlayRenderer[];
+    overlayRenderers: readonly EngineOverlayRenderer[];
     segments: readonly RenderSegment[];
 }
 /**

package/dist/view/layer/index.d.ts

@@ -2,5 +2,5 @@ export type { BlendCapableGL } from './blend.js';
 export { applyDrawBlendState } from './blend.js';
 export type { CustomLayerDeps, CustomLayerInterface } from './custom-layer.js';
 export { createCustomLayer } from './custom-layer.js';
-export type { RenderSegment, RenderSlot } from './slots.js';
-export { PRIMARY_RENDER_LAYER_ID, partitionLayerOrder, renderSlotLayerId } from './slots.js';
+export type { RenderSegment, StackSlot } from './slots.js';
+export { PRIMARY_RENDER_LAYER_ID, partitionLayerOrder, slotLayerId } from './slots.js';

package/dist/view/layer/index.js

@@ -2,4 +2,4 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 export { applyDrawBlendState } from './blend.js';
 export { createCustomLayer } from './custom-layer.js';
-export { PRIMARY_RENDER_LAYER_ID, partitionLayerOrder, renderSlotLayerId } from './slots.js';
+export { PRIMARY_RENDER_LAYER_ID, partitionLayerOrder, slotLayerId } from './slots.js';

package/dist/view/layer/render.d.ts

@@ -4,8 +4,8 @@
  * The per-layer rendering loop called from CustomLayer's render()
  */
 import type { ProjectionData } from 'maplibre-gl';
-import type { DatasetManager } from '../../display/manager.js';
-import type { CustomFeatureHandler, CustomRendererDrawContext, LayerAwareOverlayRenderer } from '../../extension/index.js';
+import type { DatasetManager } from '../../dataset/manager.js';
+import type { FeatureTypeHandler, FrameDrawContext, LayeredOverlayRenderer } from '../../extension/index.js';
 import type { Store } from '../../store/store.js';
 import type { BoundingBox, Feature, Layer } from '../../store/types.js';
 import type { FeatureCompanionRegistry } from '../feature-companion.js';
@@ -55,7 +55,7 @@ import type { StoreRetainedCache } from './store-retained.js';
  *   of the ViewportFilter when omitted). A view across the antimeridian is drawn once per
  *   copy, each with its own range
  */
-export declare function renderLayers(r: Renderers, store: Store, features: Feature[], selectedIdSet: Set<string>, defaultProjectionData: ProjectionData, zoom: number, customRenderers: Map<string, CustomFeatureHandler['renderer']>, customRendererContext: CustomRendererDrawContext, companions: FeatureCompanionRegistry, layerAwareRenderers: LayerAwareOverlayRenderer[], datasets?: DatasetManager, storeRetained?: StoreRetainedCache, restoreBlendState?: () => void, range?: RenderLayersRange, view?: RenderLayersView): void;
+export declare function renderLayers(r: Renderers, store: Store, features: Feature[], selectedIdSet: Set<string>, defaultProjectionData: ProjectionData, zoom: number, customRenderers: Map<string, FeatureTypeHandler['renderer']>, customRendererContext: FrameDrawContext, companions: FeatureCompanionRegistry, layerAwareRenderers: LayeredOverlayRenderer[], datasets?: DatasetManager, storeRetained?: StoreRetainedCache, restoreBlendState?: () => void, range?: RenderLayersRange, view?: RenderLayersView): void;
 /**
  * The context of the custom renderers for one layer (the context of the frame with the opacity
  * of the layer)
@@ -63,7 +63,7 @@ export declare function renderLayers(r: Renderers, store: Store, features: Featu
  * The same object is returned when the opacity is already the one of the context, so a map whose
  * layers are all opaque allocates nothing per layer.
  */
-export declare function layerRendererContext(base: CustomRendererDrawContext, layer: Layer): CustomRendererDrawContext;
+export declare function layerRendererContext(base: FrameDrawContext, layer: Layer): FrameDrawContext;
 /**
  * The part of the view one rendering covers (one copy of the world)
  */

package/dist/view/layer/render.js

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 import { drawFeatureCompanionsInFrame } from '../feature-companion.js';
 import { layerDrawFactors } from '../renderers/draw-factors.js';
+import { customRendererOf } from './store-retained-classify.js';
 /**
  * Draw features and overlays layer by layer
  *
@@ -131,20 +132,14 @@ export function renderLayers(r, store, features, selectedIdSet, defaultProjectio
                 // Companion drawing (feature companion): drawn right before the feature itself, that is,
                 // one z below it. If no provider at all is registered, not even has is called.
                 drawFeatureCompanionsInFrame(companions, feature, r.batchManager, defaultProjectionData, zoom, layer, layerContext, restoreBlendState);
-                const customRenderer = customRenderers.get(feature.type);
+                const customRenderer = customRendererOf(customRenderers, feature);
                 if (customRenderer) {
                     // To keep the draw order (painter's algorithm), the core batch that has accumulated is
                     // flushed first and only then the custom feature is drawn immediately.
                     // A batch is not painted until endFrame, so without flushing here a custom feature
                     // would ignore layer.order and be drawn before the core features of the same layer.
                     r.batchManager.endFrame();
-                    customRenderer.draw({
-                        id: feature.id,
-                        type: feature.type,
-                        coordinates: feature.coordinates,
-                        properties: feature.properties,
-                        style: feature.style,
-                    }, defaultProjectionData, zoom, layerContext);
+                    customRenderer.draw(feature, defaultProjectionData, zoom, layerContext);
                     // Re-establish the blend state that the external renderer may have rewritten.
                     restoreBlendState?.();
                     // Restart the batch for the core features that follow.

package/dist/view/layer/renderers.d.ts

@@ -4,7 +4,7 @@
  * Lifecycle management of every renderer that CustomLayer uses
  */
 import type { Map as MapLibreMap } from 'maplibre-gl';
-import type { CustomFeatureHandler } from '../../extension/index.js';
+import type { FeatureTypeHandler } from '../../extension/index.js';
 import type { FeatureStyleConfig } from '../../shared/config/feature-style.js';
 import type { RenderingConfig } from '../../shared/config/rendering.js';
 import type { SelectionUIConfig } from '../../shared/config/selection.js';
@@ -63,7 +63,7 @@ export interface InitRenderersDeps {
     featureStyle: FeatureStyleConfig;
     selectionConfig: SelectionUIConfig;
     renderingConfig: RenderingConfig;
-    customFeatureHandlers: CustomFeatureHandler[] | undefined;
+    customFeatureHandlers: FeatureTypeHandler[] | undefined;
     /** Injected rendering pixel ratio (when omitted, read from window every time) */
     pixelRatio?: PixelRatioInput;
     /** The state and the caches owned by the draw instance (never shared between instances) */

package/dist/view/layer/renderers.js

@@ -24,7 +24,7 @@ export function initRenderers(deps) {
     const { gl, map: mapInstance, store, spatialIndex, featureStyle, selectionConfig, renderingConfig, customFeatureHandlers, pixelRatio, scope, onImageError, } = deps;
     const textureCache = new TextureCache(gl);
     const terrain = scope.terrain;
-    const quadShader = new QuadShader(gl, terrain);
+    const quadShader = new QuadShader(gl).useTerrainState(terrain);
     const imageRenderer = new ImageRenderer(mapInstance, gl, textureCache, quadShader, (fileId) => store.getFile(fileId), onImageError);
     const strokeRenderer = new StrokeRenderer(mapInstance, gl, pixelRatio, terrain);
     const sdfLineRenderer = new SDFLineRenderer(mapInstance, gl, pixelRatio, terrain);

package/dist/view/layer/slot-manager.d.ts

@@ -9,7 +9,7 @@
  * docs/internals/rendering.md ("Slots and separators").
  */
 import type { CustomLayerInterface, Map as MapLibreMap } from 'maplibre-gl';
-import { type RenderSlot } from './slots.js';
+import { type StackSlot } from './slots.js';
 /** What the manager needs */
 export interface SlotManagerDeps {
     map: Pick<MapLibreMap, 'getLayer' | 'addLayer' | 'removeLayer'> & {
@@ -20,7 +20,7 @@ export interface SlotManagerDeps {
     /** Predicate that identifies the separators (always false when omitted = a single slot) */
     isExternalEntry?: (entryId: string) => boolean;
     /** Where the changes of the slots and of the segments are notified */
-    onSlotsChange?: (slots: RenderSlot[]) => void;
+    onSlotsChange?: (slots: StackSlot[]) => void;
     /** Creates the CustomLayer of the slot at `index` (index 1 onwards) */
     createSlotLayer: (index: number) => CustomLayerInterface;
 }

package/dist/view/layer/slot-manager.js

@@ -1,6 +1,6 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
-import { partitionLayerOrder, renderSlotLayerId, sameSegments, } from './slots.js';
+import { partitionLayerOrder, sameSegments, slotLayerId, } from './slots.js';
 /**
  * The slots of one draw instance
  *
@@ -77,9 +77,9 @@ export class SlotManager {
         return this.added === 0;
     }
     /** The list of slots (public form) */
-    getRenderSlots() {
+    getStackSlots() {
         return this.currentSegments.map((segment, index) => ({
-            layerId: this.slotLayers[index]?.id ?? renderSlotLayerId(index),
+            layerId: this.slotLayers[index]?.id ?? slotLayerId(index),
             from: segment.from,
             to: segment.to,
         }));
@@ -118,7 +118,7 @@ export class SlotManager {
                 map.removeLayer(slot.id);
             }
         }
-        onSlotsChange?.(this.getRenderSlots());
+        onSlotsChange?.(this.getStackSlots());
         map.triggerRepaint?.();
     }
     /** Whether the map has that layer (always false while the style is not loaded) */

package/dist/view/layer/slots.d.ts

@@ -8,7 +8,7 @@
  * a native layer can be placed in between our own rendering only once the slots are split per
  * segment. The design is in docs/internals/rendering.md, "Slots and separators".
  */
-export type { RenderSlot } from '../../shared/types/events.js';
+export type { StackSlot } from '../../shared/types/events.js';
 /** A segment ([from, to) in layerOrder) */
 export interface RenderSegment {
     readonly from: number;
@@ -17,7 +17,7 @@ export interface RenderSegment {
 /** Layer id of the first slot (keeps the same id as the single layer used before) */
 export declare const PRIMARY_RENDER_LAYER_ID = "maplibre-gl-draw-layer";
 /** Layer id of the slot at `index` */
-export declare function renderSlotLayerId(index: number): string;
+export declare function slotLayerId(index: number): string;
 /**
  * Split the stacking order into segments at the separators
  *

package/dist/view/layer/slots.js

@@ -3,7 +3,7 @@
 /** Layer id of the first slot (keeps the same id as the single layer used before) */
 export const PRIMARY_RENDER_LAYER_ID = 'maplibre-gl-draw-layer';
 /** Layer id of the slot at `index` */
-export function renderSlotLayerId(index) {
+export function slotLayerId(index) {
     return index === 0 ? PRIMARY_RENDER_LAYER_ID : `${PRIMARY_RENDER_LAYER_ID}:${index}`;
 }
 /**

package/dist/view/layer/store-retained-bbox.js

@@ -9,6 +9,7 @@
  */
 import { circleBoundingBox } from '../../geometry/circle.js';
 import { DEFAULT_TILE_SIZE } from '../../shared/math/index.js';
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { getCircleRadius } from '../../shared/utils/property.js';
 import { getBoundingBox } from '../../store/spatial/index.js';
 /**
@@ -170,7 +171,7 @@ export function computeFeaturesBBox(features, extensions) {
         }
         if (feature.type === 'Circle') {
             const radiusMeters = getCircleRadius(feature);
-            const center = feature.coordinates;
+            const center = coordinatesOf(feature);
             if (radiusMeters && radiusMeters > 0 && typeof center?.[0] === 'number') {
                 // The box of the geodesic circle, whose east and west extremes lie poleward of due
                 // east and west; it contains the polygon used for drawing (generateCirclePolygon).
@@ -182,7 +183,7 @@ export function computeFeaturesBBox(features, extensions) {
                 }
             }
         }
-        walkCoordinates(feature.coordinates, visit);
+        walkCoordinates(coordinatesOf(feature), visit);
     }
     return found ? [minLng, minLat, maxLng, maxLat] : null;
 }

package/dist/view/layer/store-retained-classify.d.ts

@@ -1,10 +1,3 @@
-/**
- * Classification of the Store features into runs
- *
- * A run is a sequence of features that the BatchManager of immediate mode would draw in one
- * batch. Cutting the feature list where the kind changes keeps the z-order of retained mode
- * identical to immediate mode.
- */
 import type { Feature, Layer } from '../../store/types.js';
 import type { FeatureCompanionRegistry } from '../feature-companion.js';
 import { type PointShape } from '../renderers/point/point-instance.js';
@@ -16,6 +9,11 @@ import type { RetainedStyleResolver } from '../renderers/retained.js';
  * batch kind and the point shape). A position where the kind changes becomes a run boundary.
  */
 export type RunKind = 'polygon' | 'line' | `point-${PointShape}` | 'immediate';
+/**
+ * The custom renderer that draws a feature: the one registered for its type, unless it
+ * refuses the feature, which the built-in drawing of the type then draws
+ */
+export declare function customRendererOf<R>(customTypes: ReadonlyMap<string, R>, feature: Feature): R | undefined;
 /**
  * Classifies a feature into the kind of its run
  *