@sakuzu/maplibre-gl-draw 1.0.0 → 2.0.0

package/dist/{display/columnar → table}/table.js

@@ -51,7 +51,7 @@ export function columnValue(column, row) {
  *
  * @internal
  */
-export class ColumnarGeometryColumn {
+export class GeometryColumnReader {
     /**
      * @param rows The number of rows (the length of the table), or undefined for a child of a mixed
      *   column, whose number of rows is read from its arrays
@@ -95,19 +95,19 @@ export class ColumnarGeometryColumn {
         // The messages about the geometry of a table of one type keep their short form
         const at = rows === undefined ? `${path}: ` : '';
         if (!geometry || !(geometry.type in OFFSET_LEVELS)) {
-            throw new Error(`Columnar input: ${at}unknown geometry type "${geometry?.type}"`);
+            throw new Error(`Table: ${at}unknown geometry type "${geometry?.type}"`);
         }
         if (!(geometry.coords instanceof Float64Array)) {
-            throw new Error(`Columnar input: ${path}.coords must be a Float64Array`);
+            throw new Error(`Table: ${path}.coords must be a Float64Array`);
         }
         const dimensions = geometry.dimensions ?? 2;
         if (dimensions !== 2 && dimensions !== 3) {
-            throw new Error(`Columnar input: ${at}dimensions must be 2 or 3 (got ${dimensions})`);
+            throw new Error(`Table: ${at}dimensions must be 2 or 3 (got ${dimensions})`);
         }
         const offsets = geometry.offsets ?? [];
         const levels = OFFSET_LEVELS[geometry.type];
         if (offsets.length !== levels) {
-            throw new Error(`Columnar input: ${at}a ${geometry.type} ${rows === undefined ? 'column' : 'table'} has ${levels} offset arrays (got ${offsets.length})`);
+            throw new Error(`Table: ${at}a ${geometry.type} ${rows === undefined ? 'column' : 'table'} has ${levels} offset arrays (got ${offsets.length})`);
         }
         const vertexCount = Math.floor(geometry.coords.length / dimensions);
         let length = rows;
@@ -121,15 +121,15 @@ export class ColumnarGeometryColumn {
         for (let level = 0; level < levels; level++) {
             const array = offsets[level];
             if (!(array instanceof Int32Array)) {
-                throw new Error(`Columnar input: ${at}offsets[${level}] must be an Int32Array`);
+                throw new Error(`Table: ${at}offsets[${level}] must be an Int32Array`);
             }
             if (array.length < elements + 1) {
-                throw new Error(`Columnar input: ${at}offsets[${level}] has ${array.length} entries for ${elements} elements`);
+                throw new Error(`Table: ${at}offsets[${level}] has ${array.length} entries for ${elements} elements`);
             }
             elements = array[elements];
         }
         if (elements > vertexCount) {
-            throw new Error(`Columnar input: ${at}the offsets reach coordinate ${elements} of ${vertexCount} coordinates`);
+            throw new Error(`Table: ${at}the offsets reach coordinate ${elements} of ${vertexCount} coordinates`);
         }
         this.type = geometry.type;
         this.coords = geometry.coords;
@@ -192,11 +192,11 @@ function isMixedGeometry(geometry) {
     return geometry?.type === 'Mixed';
 }
 /**
- * A validated columnar table
+ * A validated table
  *
  * @internal
  */
-export class ColumnarTable {
+export class TableReader {
     /**
      * @throws when the shape of the input does not add up (a wrong type, an offset array of the
      *   wrong length, a column shorter than the table, a row of a mixed column pointing outside its
@@ -273,7 +273,7 @@ export class ColumnarTable {
         });
         const { length, geometry } = input;
         if (!Number.isInteger(length) || length < 0) {
-            throw new Error(`Columnar input: length must be a non-negative integer (got ${length})`);
+            throw new Error(`Table: length must be a non-negative integer (got ${length})`);
         }
         if (isMixedGeometry(geometry)) {
             this.children = readMixedChildren(geometry, length);
@@ -281,21 +281,21 @@ export class ColumnarTable {
             this.childRows = geometry.offsets;
         }
         else {
-            this.children = [new ColumnarGeometryColumn(geometry, length, 'geometry')];
+            this.children = [new GeometryColumnReader(geometry, length, 'geometry')];
             this.childTypes = null;
             this.childRows = null;
         }
         this.onlyPoints = this.children.every((child) => child.type === 'Point' || child.type === 'MultiPoint');
         if (input.validity && input.validity.length < Math.ceil(length / 8)) {
-            throw new Error('Columnar input: validity is shorter than the table');
+            throw new Error('Table: validity is shorter than the table');
         }
         if (input.ids && columnLength(input.ids) < length) {
-            throw new Error('Columnar input: ids is shorter than the table');
+            throw new Error('Table: ids is shorter than the table');
         }
         const columns = input.columns ?? {};
         for (const [name, column] of Object.entries(columns)) {
             if (columnLength(column) < length) {
-                throw new Error(`Columnar input: column "${name}" is shorter than the table`);
+                throw new Error(`Table: column "${name}" is shorter than the table`);
             }
         }
         this.length = length;
@@ -420,14 +420,18 @@ export class ColumnarTable {
      * @param hasGeometry Whether the row has a geometry (a row without one is not visible)
      */
     featureAt(row, hasGeometry) {
+        const type = this.columnOf(row)?.type ?? 'Point';
         return {
             id: this.idOf(row),
-            type: this.columnOf(row)?.type ?? 'Point',
-            coordinates: this.coordinatesOf(row),
+            type,
+            // The type of a column is a GeoJSON geometry type, so it is the kind of the geometry
+            geometry: { type, coordinates: this.coordinatesOf(row) },
             layerId: '',
+            groupId: undefined,
             properties: this.propertiesOf(row),
             locked: false,
             visible: hasGeometry,
+            style: {},
         };
     }
 }
@@ -440,31 +444,31 @@ export class ColumnarTable {
 function readMixedChildren(geometry, length) {
     const { types, offsets, children } = geometry;
     if (!(types instanceof Int8Array)) {
-        throw new Error('Columnar input: geometry.types must be an Int8Array');
+        throw new Error('Table: geometry.types must be an Int8Array');
     }
     if (!(offsets instanceof Int32Array)) {
-        throw new Error('Columnar input: geometry.offsets must be an Int32Array');
+        throw new Error('Table: geometry.offsets must be an Int32Array');
     }
     if (!Array.isArray(children)) {
-        throw new Error('Columnar input: geometry.children must be an array');
+        throw new Error('Table: geometry.children must be an array');
     }
     if (types.length < length) {
-        throw new Error('Columnar input: geometry.types is shorter than the table');
+        throw new Error('Table: geometry.types is shorter than the table');
     }
     if (offsets.length < length) {
-        throw new Error('Columnar input: geometry.offsets is shorter than the table');
+        throw new Error('Table: geometry.offsets is shorter than the table');
     }
-    const columns = children.map((child, k) => new ColumnarGeometryColumn(child, undefined, `geometry.children[${k}]`));
+    const columns = children.map((child, k) => new GeometryColumnReader(child, undefined, `geometry.children[${k}]`));
     for (let row = 0; row < length; row++) {
         const child = types[row];
         if (child < 0)
             continue;
         if (child >= columns.length) {
-            throw new Error(`Columnar input: geometry.types[${row}] is ${child}, but there are ${columns.length} children`);
+            throw new Error(`Table: geometry.types[${row}] is ${child}, but there are ${columns.length} children`);
         }
         const at = offsets[row];
         if (at < 0 || at >= columns[child].length) {
-            throw new Error(`Columnar input: geometry.offsets[${row}] is ${at}, but geometry.children[${child}] has ${columns[child].length} rows`);
+            throw new Error(`Table: geometry.offsets[${row}] is ${at}, but geometry.children[${child}] has ${columns[child].length} rows`);
         }
     }
     return columns;

package/dist/{display/columnar → table}/types.d.ts

@@ -1,19 +1,24 @@
 /**
- * The columnar input of a dataset
+ * The types of a table
  *
- * The rows are given as columns of typed arrays in the layout of GeoArrow (the native encoding
+ * The rows are held as columns of typed arrays in the layout of GeoArrow (the native encoding
  * with separated offsets), so a reader of GeoParquet, Arrow or FlatGeobuf can hand what it reads
  * over without building an object per row, and a Worker can send it to the main thread without a
  * copy.
  */
+import type { BBox } from '../geometry/types.js';
 /**
- * The geometry type of a geometry column of a single type. A table whose rows have different
- * types gives a {@link DatasetColumnarMixedGeometry}, made of columns of these types.
+ * The geometry type of a geometry column of a single type.
+ *
+ * A table whose rows have different types gives a {@link TableMixedGeometry}, made of columns of
+ * these types.
  */
-export type DatasetColumnarGeometryType = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon';
+export type GeometryType = 'Point' | 'LineString' | 'Polygon' | 'MultiPoint' | 'MultiLineString' | 'MultiPolygon';
 /**
- * The geometry column of a columnar table, in the layout of GeoArrow: interleaved coordinates
- * and the offset arrays, outermost first.
+ * The geometry column of a table whose rows share one geometry type.
+ *
+ * It follows the layout of GeoArrow: interleaved coordinates and the offset arrays, outermost
+ * first.
  *
  * Every row owns a contiguous run of the coordinates, so the offsets only say where each row,
  * part and ring starts:
@@ -30,20 +35,20 @@ export type DatasetColumnarGeometryType = 'Point' | 'LineString' | 'Polygon' | '
  * the first element, the last is the end of the last), and its values never decrease.
  *
  * A row without a geometry has an empty run (two equal offsets), or NaN coordinates for a Point,
- * or a 0 bit in {@link DatasetColumnarInput.validity}. It is neither drawn nor hit.
+ * or a 0 bit in {@link Table.validity}. It is neither drawn nor hit.
  *
  * @example A table of two lines
  * ```ts
- * const geometry: DatasetColumnarGeometry = {
+ * const geometry: TableGeometry = {
  *   type: 'LineString',
  *   coords: new Float64Array([139.70, 35.68, 139.71, 35.69, 139.72, 35.66, 139.73, 35.67]),
  *   offsets: [new Int32Array([0, 2, 4])],
  * };
  * ```
  */
-export interface DatasetColumnarGeometry {
+export interface TableGeometry {
     /** The geometry type of every row */
-    type: DatasetColumnarGeometryType;
+    type: GeometryType;
     /**
      * The coordinates in degrees, interleaved: `[lng0, lat0, lng1, lat1, ...]`, or
      * `[lng0, lat0, z0, ...]` with `dimensions: 3`
@@ -58,20 +63,22 @@ export interface DatasetColumnarGeometry {
     offsets?: Int32Array[];
 }
 /**
- * The geometry column of a table whose rows have different geometry types, in the layout of the
- * mixed geometry of GeoArrow (a dense union of Arrow): a geometry column of a single type per
- * child, and for every row of the table the child and the row within it.
+ * The geometry column of a table whose rows have different geometry types.
+ *
+ * It follows the layout of the mixed geometry of GeoArrow (a dense union of Arrow): a geometry
+ * column of a single type per child, and for every row of the table the child and the row within
+ * it.
  *
  * The geometry of row `i` is row `offsets[i]` of `children[types[i]]`, and row `i` behaves exactly
  * as the feature of that child's type with those coordinates. The rows of a child can be in any
  * order; the draw order is the order of the table rows. A row with a negative `types[i]` has no
- * geometry (as a 0 bit in {@link DatasetColumnarInput.validity}, which still applies on top). The
+ * geometry (as a 0 bit in {@link Table.validity}, which still applies on top). The
  * number of rows of a child is read from its arrays: the coordinates for a Point column,
  * `offsets[0].length - 1` for the others.
  *
  * @example A point, a line and a polygon, the polygon first in the table
  * ```ts
- * const geometry: DatasetColumnarMixedGeometry = {
+ * const geometry: TableMixedGeometry = {
  *   type: 'Mixed',
  *   types: new Int8Array([2, 0, 1]),
  *   offsets: new Int32Array([0, 0, 0]),
@@ -91,7 +98,7 @@ export interface DatasetColumnarGeometry {
  * };
  * ```
  */
-export interface DatasetColumnarMixedGeometry {
+export interface TableMixedGeometry {
     /** Marks the mixed form */
     type: 'Mixed';
     /**
@@ -102,57 +109,57 @@ export interface DatasetColumnarMixedGeometry {
     /** For every row, the row within its child column */
     offsets: Int32Array;
     /** The geometry columns of a single type */
-    children: DatasetColumnarGeometry[];
+    children: TableGeometry[];
 }
 /**
- * The integer arrays that can hold the codes of a {@link DatasetDictionaryColumn}.
- */
-export type DatasetDictionaryCodes = Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array;
-/**
- * An attribute column encoded as a dictionary (the dictionary type of Arrow): the value of row
- * `i` is `dictionary[codes[i]]`. A negative code, or one past the end of the dictionary, means
- * no value (`null`).
+ * An attribute column encoded as a dictionary (the dictionary type of Arrow).
+ *
+ * The value of row `i` is `dictionary[codes[i]]`. A negative code, or one past the end of the
+ * dictionary, means no value (`null`).
  *
  * @example
  * ```ts
- * const category: DatasetDictionaryColumn = {
+ * const category: DictionaryColumn = {
  *   codes: new Int32Array([0, 1, 0, -1]),
  *   dictionary: ['cafe', 'school'],
  * }; // 'cafe', 'school', 'cafe', null
  * ```
  */
-export interface DatasetDictionaryColumn {
+export interface DictionaryColumn {
     /** The code of each row */
-    codes: DatasetDictionaryCodes;
+    codes: Int8Array | Uint8Array | Int16Array | Uint16Array | Int32Array | Uint32Array;
     /** The distinct values */
     dictionary: readonly (string | number | boolean | null)[];
 }
 /**
- * An attribute column of a columnar table: a typed array of numbers, a dictionary, or a plain
- * array of values. Row `i` of the table is element `i` of the column. In a `Float64Array` or a
- * `Float32Array`, NaN means no value (`null`).
+ * An attribute column of a table: a typed array of numbers, a dictionary, or a plain array.
+ *
+ * Row `i` of the table is element `i` of the column. In a `Float64Array` or a `Float32Array`,
+ * NaN means no value (`null`).
  */
-export type DatasetColumn = Float64Array | Float32Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array | DatasetDictionaryColumn | readonly unknown[];
+export type Column = Float64Array | Float32Array | Int32Array | Uint32Array | Int16Array | Uint16Array | Int8Array | Uint8Array | DictionaryColumn | readonly unknown[];
 /**
- * The rows of a dataset given as columns, the counterpart of an array of
- * {@link DatasetFeatureInput}. Pass it as `columnar` to
- * {@link MapLibreGLDraw.addDataset} or to {@link Dataset.setColumnar}.
+ * A table of rows held as columns, the fast way to put many rows on the map.
+ *
+ * Build one with {@link tableFromFeatures} or {@link createTableBuilder}, or take the output of
+ * a GeoArrow reader as it is: the layout is the same. Pass it as `table` to
+ * {@link maplibre-gl-draw!DatasetsCollection.add | draw.datasets.add} or to
+ * {@link maplibre-gl-draw!Dataset.setTable | Dataset.setTable}.
  *
  * Nothing is copied: the dataset keeps and reads the arrays, so do not change them while the
- * dataset holds them (replace the table with `setColumnar` instead). Every array can be sent
- * from a Worker without a copy; `columnarTransferables` from
- * `@sakuzu/maplibre-gl-draw/columnar` lists their buffers.
+ * dataset holds them (replace the table with `setTable` instead). Every array can be sent from a
+ * Worker without a copy; {@link transferList} lists their buffers.
  *
  * Row `i` behaves as the feature `{ id, type: geometry.type, coordinates, properties }` where
  * `coordinates` are read from the geometry column, `properties` holds the value of every column at
  * row `i`, and `id` is `String(ids[i])` (or `String(i)` without `ids`). With a
- * {@link DatasetColumnarMixedGeometry}, `type` and `coordinates` are those of the row's child
+ * {@link TableMixedGeometry}, `type` and `coordinates` are those of the row's child
  * column. The rows have no individual style; the style rule and the base style of the dataset
  * color them.
  *
  * @example
  * ```ts
- * const places: DatasetColumnarInput = {
+ * const places: Table = {
  *   length: 3,
  *   geometry: {
  *     type: 'Point',
@@ -163,17 +170,17 @@ export type DatasetColumn = Float64Array | Float32Array | Int32Array | Uint32Arr
  *     visitors: new Float64Array([3.5, 0.7, 3.0]),
  *   },
  * };
- * draw.addDataset({ id: 'places', columnar: places });
+ * draw.datasets.add({ id: 'places', table: places });
  * ```
  */
-export interface DatasetColumnarInput {
+export interface Table {
     /** The number of rows */
     length: number;
     /**
-     * The geometry column: of one type, or {@link DatasetColumnarMixedGeometry} for rows of
+     * The geometry column: of one type, or {@link TableMixedGeometry} for rows of
      * different types
      */
-    geometry: DatasetColumnarGeometry | DatasetColumnarMixedGeometry;
+    geometry: TableGeometry | TableMixedGeometry;
     /**
      * Which rows have a geometry, as the validity bitmap of Arrow: bit `i % 8` of byte `i >> 3` (the
      * lowest bit first) is 1 for a row with a geometry. Every row has one when omitted
@@ -183,41 +190,30 @@ export interface DatasetColumnarInput {
      * The id of each row, turned into a string with `String()` (the row number as a string when
      * omitted). The ids must be unique within the table
      */
-    ids?: DatasetColumn;
+    ids?: Column;
     /**
      * The attribute columns by name. They become the `properties` of the rows, which the style
      * rule reads. Passing only the columns that the rule and the host read is enough
      */
-    columns?: Record<string, DatasetColumn>;
+    columns?: Record<string, Column>;
 }
 /**
- * What `prepareDatasetColumnar` (from `@sakuzu/maplibre-gl-draw/columnar`) computes from a
- * columnar table so that the main thread does not have to: the bbox of each row, the spatial
- * chunks and the spatial index of the hit testing.
+ * A table together with what {@link prepareTable} computed for it, ready for the main thread.
  *
- * Every field is a typed array, so it can be sent from a Worker without a copy. Treat it as
- * opaque: pass it with the same table to {@link Dataset.setColumnar} or as `prepared` to
- * {@link MapLibreGLDraw.addDataset}.
+ * Besides the table it carries the bbox of each row, the spatial chunks and the spatial index
+ * of the hit testing, all in typed arrays, so it can be sent from a Worker without a copy
+ * ({@link transferList}). It also tells the number of rows and the extent of the table. Treat
+ * everything else as opaque: pass the whole object as `table` to {@link maplibre-gl-draw!DatasetsCollection.add | draw.datasets.add} or to
+ * {@link maplibre-gl-draw!Dataset.setTable | Dataset.setTable}.
  */
-export interface DatasetColumnarPrepared {
-    /** The number of rows it was computed for (it must equal the `length` of the table) */
+export interface PreparedTable {
+    /** The table the rest was computed for */
+    readonly table: Table;
+    /** The number of rows, the `length` of the table it was computed for */
     readonly length: number;
-    /** The bbox of each row, `[minX, minY, maxX, maxY]` (NaN for a row without a geometry) */
-    readonly bounds: Float64Array;
-    /** The rows of every chunk, chunk after chunk */
-    readonly chunkRows: Int32Array;
-    /** Where each chunk starts in `chunkRows` (the chunk count + 1 entries) */
-    readonly chunkOffsets: Int32Array;
-    /** The bbox of each chunk, `[minX, minY, maxX, maxY]` */
-    readonly chunkBounds: Float64Array;
-    /** The number of entries of one node of the spatial index */
-    readonly indexNodeSize: number;
-    /** The number of leaves of the spatial index (the rows with a geometry) */
-    readonly indexItemCount: number;
-    /** The boxes of the spatial index */
-    readonly indexBoxes: Float64Array;
-    /** The rows and child positions of the spatial index */
-    readonly indexEntries: Int32Array;
-    /** The end of each level of the spatial index */
-    readonly indexLevels: Int32Array;
+    /**
+     * The extent of the rows with a geometry, as `[west, south, east, north]` in degrees, or
+     * `null` when no row has a geometry
+     */
+    readonly bounds: BBox | null;
 }

package/dist/table/types.js

@@ -0,0 +1,3 @@
+// SPDX-FileCopyrightText: 2026 SAKAIDA Atsushi
+// SPDX-License-Identifier: AGPL-3.0-only
+export {};

package/dist/view/coordinator.js

@@ -5,15 +5,16 @@
  */
 function shouldRepaint(changes) {
     // A repaint is required if any of the following changed
-    return !!((changes.features || // creation, update or deletion of features
+    return !!(changes.features || // creation, update or deletion of features
         changes.layers || // layer changes
         changes.groups || // group changes (reordering, show/hide)
         changes.layerReorder || // reordering of items within a layer
         changes.groupReorder || // reordering of features within a group
         changes.selection || // selection state changes
         changes.tentative || // changes to the transient state while drawing
-        changes.uiStateChanged) // changes to the UI state (dragState, boxSelection)
-    );
+        changes.uiStateChanged || // changes to the UI state (dragState, boxSelection)
+        // the whole document replaced
+        changes.reset);
 }
 /**
  * RenderCoordinator implementation

package/dist/view/feature-companion.d.ts

@@ -26,11 +26,12 @@
  * registry per draw instance (createFeatureCompanionRegistry). When several instances
  * (the hidden renderers of printing and thumbnails) hold different Stores that have the
  * same feature ids, the provider has no way to tell "is this a feature of my own Store?"
- * (a replaced DocumentStore may return a new object from getFeature every time, so identity
+ * (a replaced Store may return a new object from getFeature every time, so identity
  * cannot be used), so ownership is expressed by separating the registries.
  */
 import type { ProjectionData } from 'maplibre-gl';
-import type { CustomRendererDrawContext } from '../extension/index.js';
+import type { MouseNormalizedEvent } from '../dispatcher/types.js';
+import type { FrameDrawContext } from '../extension/index.js';
 import type { LngLat, ScreenPoint } from '../shared/math/index.js';
 import type { Coordinate, Feature } from '../store/types.js';
 /**
@@ -67,7 +68,8 @@ export interface CompanionHitContext {
  * Draws something that accompanies a feature (a label, a callout) right below it in the
  * draw order, and makes it clickable in the same order.
  *
- * Register one with `draw.registerFeatureCompanionProvider(provider)`. What is drawn and what
+ * A `CompanionProvider` of `draw.extensions.companionProviders` is installed as one. What is
+ * drawn and what
  * is hit are resolved at the same position of the z order, so what is visible is what can be
  * grabbed. A click on a companion does not change the selection; it is handed to
  * `onCompanionClick`.
@@ -88,10 +90,11 @@ export interface FeatureCompanionProvider {
      * core flushes the batch in progress before and after the call, so what is drawn always
      * comes below this feature and above the feature one step further back.
      */
-    draw(feature: Feature, projectionData: ProjectionData, zoom: number, context: CustomRendererDrawContext): void;
+    draw(feature: Feature, projectionData: ProjectionData, zoom: number, context: FrameDrawContext): void;
     /**
      * Called in the z scan of click resolution, after the feature itself misses and before
-     * the next feature.
+     * the next feature. The feature itself is hit on what it draws (the marker of a point
+     * included) with the click tolerance, so it always wins over its own companion.
      *
      * If it returns a hit, core consumes that click (it does not change the selection state,
      * nor does it clear the selection as an empty click would) and calls
@@ -99,12 +102,15 @@ export interface FeatureCompanionProvider {
      */
     hitTest(feature: Feature, point: ScreenPoint, context: CompanionHitContext): CompanionHit | null;
     /**
-     * The notification of a consumed click.
+     * The notification of a click on the companion.
      *
      * @param featureId The ID of the feature that owns the companion
      * @param hit The hit returned by hitTest
+     * @param event The click, when the engine has one to give
+     * @returns False to leave the click to the select mode, as a click on the feature that owns
+     *   the companion; anything else consumes it
      */
-    onCompanionClick(featureId: string, hit: CompanionHit): void;
+    onCompanionClick(featureId: string, hit: CompanionHit, event?: MouseNormalizedEvent): boolean | undefined;
 }
 /**
  * A companion hit resolved in the z scan, with the provider and the feature it belongs to.

package/dist/view/feature-companion.js

@@ -96,13 +96,21 @@ export function hitTestFeatureCompanions(registry, feature, context) {
     return null;
 }
 /**
- * Hands a consumed click back to the provider
+ * Hands a click on a companion to its provider
  *
  * If the provider has already been unregistered, nothing happens (the click stays
  * consumed and the selection state does not change).
  *
+ * @returns Whether the click was consumed; false when the provider leaves it to the select
+ *   mode
  * @internal
  */
-export function notifyFeatureCompanionClick(registry, result) {
-    registry.get(result.providerId)?.onCompanionClick(result.featureId, result.hit);
+export function notifyFeatureCompanionClick(registry, result, event) {
+    const provider = registry.get(result.providerId);
+    if (!provider)
+        return true;
+    const consumed = event === undefined
+        ? provider.onCompanionClick(result.featureId, result.hit)
+        : provider.onCompanionClick(result.featureId, result.hit, event);
+    return consumed !== false;
 }

package/dist/view/globe-subdivision.js

@@ -20,7 +20,7 @@
  * On a flat map nothing here is used and the geometry is exactly what it was.
  */
 import { densifyOnMercatorPlane, globeSubdivisionGrid, } from '../shared/math/globe-subdivision.js';
-import { getTerrainTessellationStep, tessellatePolygonFill } from './terrain/polygon.js';
+import { terrainStepOf, tessellatePolygonFill } from './terrain/polygon.js';
 import { mercatorX, mercatorY } from './terrain/tessellation.js';
 /**
  * The most points the globe adds to one fill or one path
@@ -75,7 +75,7 @@ export function getGlobeTessellationStep(context, kind) {
  * @param kind Which cell of the globe applies (the terrain has one step for everything)
  */
 export function getSurfaceTessellationStep(context, kind) {
-    return getTerrainTessellationStep(context) ?? getGlobeTessellationStep(context, kind);
+    return terrainStepOf(context) ?? getGlobeTessellationStep(context, kind);
 }
 /**
  * Subdivides the fill of one feature with the step of the surface
@@ -85,7 +85,7 @@ export function getSurfaceTessellationStep(context, kind) {
  * large dataset are that small at the zooms the globe is seen at.
  */
 export function tessellateSurfaceFill(context, featureId, partIndex, flatCoords, indices, step) {
-    if (!getTerrainTessellationStep(context) && withinOneCell(flatCoords, step.grid)) {
+    if (!terrainStepOf(context) && withinOneCell(flatCoords, step.grid)) {
         return { flatCoords, indices, step };
     }
     return tessellatePolygonFill(context, featureId, partIndex, flatCoords, indices, step);

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

@@ -1,6 +1,6 @@
 import type { CustomLayerInterface, Map as MapLibreMap } from 'maplibre-gl';
 /**
- * Keeps the render slots of Draw on the map for as long as the returned detach function has not
+ * 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

package/dist/view/layer/attach.js

@@ -12,7 +12,7 @@ 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
+ * 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