@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

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
  *

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

@@ -1,6 +1,18 @@
 // SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
 // SPDX-License-Identifier: AGPL-3.0-only
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { toInstancedPointShape } from '../renderers/point/point-instance.js';
+/**
+ * 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 function customRendererOf(customTypes, feature) {
+    const renderer = customTypes.get(feature.type);
+    if (renderer === undefined)
+        return undefined;
+    const { appliesTo } = renderer;
+    return appliesTo && !appliesTo.call(renderer, feature) ? undefined : renderer;
+}
 /**
  * Classifies a feature into the kind of its run
  *
@@ -13,7 +25,7 @@ import { toInstancedPointShape } from '../renderers/point/point-instance.js';
  */
 export function classifyFeature(feature, styles, customTypes, companions, layer) {
     // A custom type is drawn immediately (it cannot go on a core batch)
-    if (customTypes.has(feature.type))
+    if (customRendererOf(customTypes, feature))
         return 'immediate';
     // A feature that has a companion (feature companion) needs a hook right before it, so it cannot
     // go on a retained batch. It is split out into an immediate chunk and drawn one at a time (on
@@ -59,29 +71,29 @@ export function featureOrigin(feature) {
         return [0, 0];
     switch (feature.type) {
         case 'MultiPoint': {
-            const coord = feature.coordinates[0];
+            const coord = coordinatesOf(feature)[0];
             return coord ? [coord[0], coord[1]] : [0, 0];
         }
         case 'LineString':
         case 'Freehand': {
-            const coord = feature.coordinates[0];
+            const coord = coordinatesOf(feature)[0];
             return coord ? [coord[0], coord[1]] : [0, 0];
         }
         case 'MultiLineString': {
-            const coord = feature.coordinates[0]?.[0];
+            const coord = coordinatesOf(feature)[0]?.[0];
             return coord ? [coord[0], coord[1]] : [0, 0];
         }
         case 'Polygon': {
-            const coord = feature.coordinates[0]?.[0];
+            const coord = coordinatesOf(feature)[0]?.[0];
             return coord ? [coord[0], coord[1]] : [0, 0];
         }
         case 'MultiPolygon': {
-            const coord = feature.coordinates[0]?.[0]?.[0];
+            const coord = coordinatesOf(feature)[0]?.[0]?.[0];
             return coord ? [coord[0], coord[1]] : [0, 0];
         }
         default: {
             // A single coordinate, such as Point / Circle
-            const coord = feature.coordinates;
+            const coord = coordinatesOf(feature);
             return Array.isArray(coord) && typeof coord[0] === 'number' ? [coord[0], coord[1]] : [0, 0];
         }
     }

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

@@ -7,6 +7,7 @@
  * and the result is baked into the vertex or instance data of the batch.
  */
 import { generateCirclePolygon } from '../../shared/math/index.js';
+import { coordinatesOf } from '../../shared/utils/coordinates.js';
 import { getCircleRadius, getCreatedZoom } from '../../shared/utils/property.js';
 import { toLineBatchItem, toPointInstanceData } from '../renderers/batch-manager.js';
 /**
@@ -37,11 +38,11 @@ export function collectLineItems(features, styles, layer) {
             items.push(item);
         };
         if (feature.type === 'MultiLineString') {
-            for (const part of feature.coordinates)
+            for (const part of coordinatesOf(feature))
                 push(part);
         }
         else {
-            push(feature.coordinates);
+            push(coordinatesOf(feature));
         }
     }
     return items;
@@ -85,7 +86,7 @@ export function collectPolygons(features, styles, layer) {
             });
         };
         if (feature.type === 'MultiPolygon') {
-            const parts = feature.coordinates;
+            const parts = coordinatesOf(feature);
             for (let i = 0; i < parts.length; i++)
                 push(parts[i], i);
         }
@@ -93,10 +94,10 @@ export function collectPolygons(features, styles, layer) {
             const radiusMeters = getCircleRadius(feature);
             if (!radiusMeters || radiusMeters <= 0)
                 continue;
-            push([generateCirclePolygon(feature.coordinates, radiusMeters)], 0);
+            push([generateCirclePolygon(coordinatesOf(feature), radiusMeters)], 0);
         }
         else {
-            push(feature.coordinates, 0);
+            push(coordinatesOf(feature), 0);
         }
     }
     return polygons;
@@ -109,12 +110,12 @@ export function collectPoints(features, styles, layer) {
     for (const feature of features) {
         const style = styles.getPointStyle(feature, layer);
         if (feature.type === 'MultiPoint') {
-            for (const coord of feature.coordinates) {
+            for (const coord of coordinatesOf(feature)) {
                 points.push(toPointInstanceData(coord, style));
             }
         }
         else {
-            points.push(toPointInstanceData(feature.coordinates, style));
+            points.push(toPointInstanceData(coordinatesOf(feature), style));
         }
     }
     return points;

package/dist/view/layer/store-retained-coord-patch.d.ts

@@ -1,11 +1,3 @@
-/**
- * Incremental update of the coordinate texture of a retained line chunk
- *
- * A vertex drag moves only a few vertices. Rebuilding a line chunk with many vertices every frame
- * would overflow the frame, so the diff of the vertices that moved is queued on the chunk and,
- * right before drawing, only the corresponding texels of the coordinate texture are rewritten
- * (see SDFLineRenderer.patchRetainedBatchCoords).
- */
 import type { Coordinate, Feature } from '../../store/types.js';
 import type { RetainedLineBatch } from '../renderers/line/line-types.js';
 import type { SDFLineRenderer } from '../renderers/line/sdf-line.js';