maplibre-gl 3.1.0 → 3.2.0-pre.2

package/src/symbol/collision_feature.ts

@@ -1,6 +1,6 @@
 import type {CollisionBoxArray} from '../data/array_types.g';
 import Point from '@mapbox/point-geometry';
-import type Anchor from './anchor';
+import type {Anchor} from './anchor';
 import {SymbolPadding} from '../style/style_layer/symbol_style_layer';
 
 /**
@@ -8,10 +8,8 @@ import {SymbolPadding} from '../style/style_layer/symbol_style_layer';
  * It is used with CollisionIndex to check if the label overlaps with any
  * previous labels. A CollisionFeature is mostly just a set of CollisionBox
  * objects.
- *
- * @private
  */
-class CollisionFeature {
+export class CollisionFeature {
     boxStartIndex: number;
     boxEndIndex: number;
     circleDiameter: number;
@@ -20,12 +18,11 @@ class CollisionFeature {
      * Create a CollisionFeature, adding its collision box data to the given collisionBoxArray in the process.
      * For line aligned labels a collision circle diameter is computed instead.
      *
-     * @param anchor The point along the line around which the label is anchored.
-     * @param shaped The text or icon shaping results.
-     * @param boxScale A magic number used to convert from glyph metrics units to geometry units.
-     * @param padding The amount of padding to add around the label edges.
-     * @param alignLine Whether the label is aligned with the line or the viewport.
-     * @private
+     * @param anchor - The point along the line around which the label is anchored.
+     * @param shaped - The text or icon shaping results.
+     * @param boxScale - A magic number used to convert from glyph metrics units to geometry units.
+     * @param padding - The amount of padding to add around the label edges.
+     * @param alignLine - Whether the label is aligned with the line or the viewport.
      */
     constructor(collisionBoxArray: CollisionBoxArray,
         anchor: Anchor,
@@ -105,5 +102,3 @@ class CollisionFeature {
         this.boxEndIndex = collisionBoxArray.length;
     }
 }
-
-export default CollisionFeature;

package/src/symbol/collision_index.test.ts

@@ -1,7 +1,7 @@
-import CollisionIndex from './collision_index';
+import {CollisionIndex} from './collision_index';
 import {mat4} from 'gl-matrix';
 
-import Transform from '../geo/transform';
+import {Transform} from '../geo/transform';
 
 describe('CollisionIndex', () => {
 

package/src/symbol/collision_index.ts

@@ -1,15 +1,15 @@
 import Point from '@mapbox/point-geometry';
-import clipLine from './clip_line';
-import PathInterpolator from './path_interpolator';
+import {clipLine} from './clip_line';
+import {PathInterpolator} from './path_interpolator';
 
 import * as intersectionTests from '../util/intersection_tests';
-import GridIndex from './grid_index';
+import {GridIndex} from './grid_index';
 import {mat4, vec4} from 'gl-matrix';
 import ONE_EM from '../symbol/one_em';
 
 import * as projection from '../symbol/projection';
 
-import type Transform from '../geo/transform';
+import type {Transform} from '../geo/transform';
 import type {SingleCollisionBox} from '../data/bucket/symbol_bucket';
 import type {
     GlyphOffsetArray,
@@ -41,10 +41,8 @@ export type FeatureKey = {
  * there's room for a symbol, then insertCollisionBox/Circles actually puts the
  * symbol in the index. The two step process allows paired symbols to be inserted
  * together even if they overlap.
- *
- * @private
  */
-class CollisionIndex {
+export class CollisionIndex {
     grid: GridIndex<FeatureKey>;
     ignoredGrid: GridIndex<FeatureKey>;
     transform: Transform;
@@ -282,8 +280,6 @@ class CollisionIndex {
      * Because the geometries in the CollisionIndex are an approximation of the shape of
      * symbols on the map, we use the CollisionIndex to look up the symbol part of
      * `queryRenderedFeatures`.
-     *
-     * @private
      */
     queryRenderedSymbols(viewportQueryGeometry: Array<Point>) {
         if (viewportQueryGeometry.length === 0 || (this.grid.keysLength() === 0 && this.ignoredGrid.keysLength() === 0)) {
@@ -402,5 +398,3 @@ class CollisionIndex {
         return m;
     }
 }
-
-export default CollisionIndex;

package/src/symbol/cross_tile_symbol_index.test.ts

@@ -1,6 +1,6 @@
-import CrossTileSymbolIndex, {KDBUSH_THRESHHOLD} from './cross_tile_symbol_index';
+import {CrossTileSymbolIndex, KDBUSH_THRESHHOLD} from './cross_tile_symbol_index';
 import {OverscaledTileID} from '../source/tile_id';
-import StyleLayer from '../style/style_layer';
+import {StyleLayer} from '../style/style_layer';
 
 const styleLayer = {
     id: 'test'

package/src/symbol/cross_tile_symbol_index.ts

@@ -1,13 +1,13 @@
 import KDBush from 'kdbush';
-import EXTENT from '../data/extent';
+import {EXTENT} from '../data/extent';
 
 import {SymbolInstanceArray} from '../data/array_types.g';
 
 import type {SymbolInstance} from '../data/array_types.g';
 import type {OverscaledTileID} from '../source/tile_id';
-import type SymbolBucket from '../data/bucket/symbol_bucket';
-import type StyleLayer from '../style/style_layer';
-import type Tile from '../source/tile';
+import type {SymbolBucket} from '../data/bucket/symbol_bucket';
+import type {StyleLayer} from '../style/style_layer';
+import type {Tile} from '../source/tile';
 
 /*
     The CrossTileSymbolIndex generally works on the assumption that
@@ -307,7 +307,7 @@ class CrossTileSymbolLayerIndex {
     }
 }
 
-class CrossTileSymbolIndex {
+export class CrossTileSymbolIndex {
     layerIndexes: {[layerId: string]: CrossTileSymbolLayerIndex};
     crossTileIDs: CrossTileIDs;
     maxBucketInstanceId: number;
@@ -365,5 +365,3 @@ class CrossTileSymbolIndex {
         }
     }
 }
-
-export default CrossTileSymbolIndex;

package/src/symbol/get_anchors.ts

@@ -1,7 +1,7 @@
 import {interpolates} from '@maplibre/maplibre-gl-style-spec';
 
-import Anchor from '../symbol/anchor';
-import checkMaxAngle from './check_max_angle';
+import {Anchor} from '../symbol/anchor';
+import {checkMaxAngle} from './check_max_angle';
 
 import type Point from '@mapbox/point-geometry';
 import type {Shaping, PositionedIcon} from './shaping';

package/src/symbol/grid_index.test.ts

@@ -1,4 +1,4 @@
-import GridIndex from './grid_index';
+import {GridIndex} from './grid_index';
 import type {GridKey} from './grid_index';
 
 describe('GridIndex', () => {

package/src/symbol/grid_index.ts

@@ -26,6 +26,9 @@ type QueryResult<T> = {
     y2: number;
 };
 
+/**
+ * A key for the grid
+ */
 export type GridKey = {
     overlapMode?: OverlapMode;
 }
@@ -54,10 +57,8 @@ function overlapAllowed(overlapA: OverlapMode, overlapB: OverlapMode): boolean {
  * at least one cell. As long as the geometries are relatively
  * uniformly distributed across the plane, this greatly reduces
  * the number of comparisons necessary.
- *
- * @private
  */
-class GridIndex<T extends GridKey> {
+export class GridIndex<T extends GridKey> {
     circleKeys: Array<T>;
     boxKeys: Array<T>;
     boxCells: Array<Array<number>>;
@@ -410,5 +411,3 @@ class GridIndex<T extends GridKey> {
         return (dx * dx + dy * dy <= (radius * radius));
     }
 }
-
-export default GridIndex;

package/src/symbol/merge_lines.test.ts

@@ -1,4 +1,4 @@
-import mergeLines from './merge_lines';
+import {mergeLines} from './merge_lines';
 import Point from '@mapbox/point-geometry';
 
 function makeFeatures(lines) {

package/src/symbol/merge_lines.ts

@@ -1,6 +1,6 @@
 import type {SymbolFeature} from '../data/bucket/symbol_bucket';
 
-export default function mergeLines(features: Array<SymbolFeature>): Array<SymbolFeature> {
+export function mergeLines(features: Array<SymbolFeature>): Array<SymbolFeature> {
     const leftIndex: {[_: string]: number} = {};
     const rightIndex: {[_: string]: number} = {};
     const mergedFeatures = [];

package/src/symbol/opacity_state.ts

@@ -1,6 +1,6 @@
 import {register} from '../util/web_worker_transfer';
 
-class OpacityState {
+export class OpacityState {
     opacity: number;
     targetOpacity: number;
     time: number;
@@ -21,5 +21,3 @@ class OpacityState {
 }
 
 register('OpacityState', OpacityState);
-
-export default OpacityState;

package/src/symbol/path_interpolator.test.ts

@@ -1,5 +1,5 @@
 import Point from '@mapbox/point-geometry';
-import PathInterpolator from './path_interpolator';
+import {PathInterpolator} from './path_interpolator';
 
 describe('PathInterpolator', () => {
 

package/src/symbol/path_interpolator.ts

@@ -1,7 +1,7 @@
 import {clamp} from '../util/util';
 import Point from '@mapbox/point-geometry';
 
-class PathInterpolator {
+export class PathInterpolator {
     points: Array<Point>;
     length: number;
     paddedLength: number;
@@ -53,5 +53,3 @@ class PathInterpolator {
         return this.points[idxOfPrevPoint].mult(1.0 - segmentT).add(this.points[currentIndex].mult(segmentT));
     }
 }
-
-export default PathInterpolator;

package/src/symbol/placement.ts

@@ -1,27 +1,27 @@
-import CollisionIndex from './collision_index';
+import {CollisionIndex} from './collision_index';
 import type {FeatureKey} from './collision_index';
-import EXTENT from '../data/extent';
+import {EXTENT} from '../data/extent';
 import * as symbolSize from './symbol_size';
 import * as projection from './projection';
 import {getAnchorJustification, evaluateVariableOffset} from './symbol_layout';
 import {getAnchorAlignment, WritingMode} from './shaping';
 import {mat4} from 'gl-matrix';
-import pixelsToTileUnits from '../source/pixels_to_tile_units';
+import {pixelsToTileUnits} from '../source/pixels_to_tile_units';
 import Point from '@mapbox/point-geometry';
-import type Transform from '../geo/transform';
-import type StyleLayer from '../style/style_layer';
+import type {Transform} from '../geo/transform';
+import type {StyleLayer} from '../style/style_layer';
 import {PossiblyEvaluated} from '../style/properties';
 import type {SymbolLayoutProps, SymbolLayoutPropsPossiblyEvaluated} from '../style/style_layer/symbol_style_layer_properties.g';
 import {getOverlapMode, OverlapMode} from '../style/style_layer/overlap_mode';
 
-import type Tile from '../source/tile';
-import SymbolBucket, {CollisionArrays, SingleCollisionBox} from '../data/bucket/symbol_bucket';
+import type {Tile} from '../source/tile';
+import {SymbolBucket, CollisionArrays, SingleCollisionBox} from '../data/bucket/symbol_bucket';
 
 import type {CollisionBoxArray, CollisionVertexArray, SymbolInstance} from '../data/array_types.g';
-import type FeatureIndex from '../data/feature_index';
+import type {FeatureIndex} from '../data/feature_index';
 import type {OverscaledTileID} from '../source/tile_id';
 import type {TextAnchor} from './symbol_layout';
-import Terrain from '../render/terrain';
+import {Terrain} from '../render/terrain';
 import {warnOnce} from '../util/util';
 
 class OpacityState {

package/src/symbol/projection.ts

@@ -4,9 +4,9 @@ import {mat4, vec4} from 'gl-matrix';
 import * as symbolSize from './symbol_size';
 import {addDynamicAttributes} from '../data/bucket/symbol_bucket';
 
-import type Painter from '../render/painter';
-import type Transform from '../geo/transform';
-import type SymbolBucket from '../data/bucket/symbol_bucket';
+import type {Painter} from '../render/painter';
+import type {Transform} from '../geo/transform';
+import type {SymbolBucket} from '../data/bucket/symbol_bucket';
 import type {
     GlyphOffsetArray,
     SymbolLineVertexArray,
@@ -377,45 +377,66 @@ type IndexToPointCache = { [lineIndex: number]: Point };
  * Since we will use the same vertices for potentially many glyphs, cache the results for this bucket
  * over the course of the render. Each vertex location also potentially has one offset equivalent
  * for us to hold onto. The vertex indices are per-symbol-bucket.
- *
- * @typedef {Object} ProjectionCache
- * @property {IndexToPointCache} projections tile-unit vertices projected into label-plane units
- * @property {IndexToPointCache} offsets label-plane vertices which have been shifted to follow an offset line
  */
 type ProjectionCache = {
+    /**
+     * tile-unit vertices projected into label-plane units
+     */
     projections: IndexToPointCache;
+    /**
+     * label-plane vertices which have been shifted to follow an offset line
+     */
     offsets: IndexToPointCache;
 };
 
 /**
  * Arguments necessary to project a vertex to the label plane
- * @typedef {Object} ProjectionArgs
- * @property {ProjectionCache} projectionCache Used to cache results, save cost if projecting the same vertex multiple times
- * @property {SymbolLineVertexArray} lineVertexArray The array of tile-unit vertices transferred from worker
- * @property {mat4} labelPlaneMatrix Label plane projection matrix
- * @property {Function} getElevation Function to get elevation at a point
- * @property {Point} tileAnchorPoint Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
- * @property {number} distanceFromAnchor Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
- * @property {Point} previousVertex Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
- * @property {number} direction Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
- * @property {number} absOffsetX Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
  */
 type ProjectionArgs = {
+    /**
+     * Used to cache results, save cost if projecting the same vertex multiple times
+     */
     projectionCache: ProjectionCache;
+    /**
+     * The array of tile-unit vertices transferred from worker
+     */
     lineVertexArray: SymbolLineVertexArray;
+    /**
+     * Label plane projection matrix
+     */
     labelPlaneMatrix: mat4;
+    /**
+     * Function to get elevation at a point
+     * @param x - the x coordinate
+     * @param y - the y coordinate
+    */
     getElevation: (x: number, y: number) => number;
+    /**
+     * Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
+     */
     tileAnchorPoint: Point;
+    /**
+     * Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
+     */
     distanceFromAnchor: number;
+    /**
+     * Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
+     */
     previousVertex: Point;
+    /**
+     * Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
+     */
     direction: number;
+    /**
+     * Only for creating synthetic vertices if vertex would otherwise project behind plane of camera
+     */
     absOffsetX: number;
 };
 
 /**
  * Transform a vertex from tile coordinates to label plane coordinates
- * @param index index of vertex to project
- * @param projectionArgs necessary data to project a vertex
+ * @param index - index of vertex to project
+ * @param projectionArgs - necessary data to project a vertex
  * @returns the vertex projected to the label plane
  */
 function projectVertexToViewport(index: number, projectionArgs: ProjectionArgs): Point {
@@ -442,9 +463,9 @@ function projectVertexToViewport(index: number, projectionArgs: ProjectionArgs):
 
 /**
  * Calculate the normal vector for a line segment
- * @param segmentVector will be mutated as a tiny optimization
- * @param offset magnitude of resulting vector
- * @param direction direction of line traversal
+ * @param segmentVector - will be mutated as a tiny optimization
+ * @param offset - magnitude of resulting vector
+ * @param direction - direction of line traversal
  * @returns a normal vector from the segment, with magnitude equal to offset amount
  */
 function transformToOffsetNormal(segmentVector: Point, offset: number, direction: number): Point {
@@ -455,14 +476,14 @@ function transformToOffsetNormal(segmentVector: Point, offset: number, direction
  * Construct offset line segments for the current segment and the next segment, then extend/shrink
  * the segments until they intersect. If the segments are parallel, then they will touch with no modification.
  *
- * @param index Index of the current vertex
- * @param prevToCurrentOffsetNormal Normal vector of the line segment from the previous vertex to the current vertex
- * @param currentVertex Current (non-offset) vertex projected to the label plane
- * @param lineStartIndex Beginning index for the line this label is on
- * @param lineEndIndex End index for the line this label is on
- * @param offsetPreviousVertex The previous vertex projected to the label plane, and then offset along the previous segments normal
- * @param lineOffsetY Magnitude of the offset
- * @param projectionArgs Necessary data for tile-to-label-plane projection
+ * @param index - Index of the current vertex
+ * @param prevToCurrentOffsetNormal - Normal vector of the line segment from the previous vertex to the current vertex
+ * @param currentVertex - Current (non-offset) vertex projected to the label plane
+ * @param lineStartIndex - Beginning index for the line this label is on
+ * @param lineEndIndex - End index for the line this label is on
+ * @param offsetPreviousVertex - The previous vertex projected to the label plane, and then offset along the previous segments normal
+ * @param lineOffsetY - Magnitude of the offset
+ * @param projectionArgs - Necessary data for tile-to-label-plane projection
  * @returns The point at which the current and next line segments intersect, once offset and extended/shrunk to their meeting point
  */
 function findOffsetIntersectionPoint(index: number, prevToCurrentOffsetNormal: Point, currentVertex: Point, lineStartIndex: number, lineEndIndex: number, offsetPreviousVertex: Point, lineOffsetY: number, projectionArgs: ProjectionArgs) {
@@ -492,14 +513,20 @@ function findOffsetIntersectionPoint(index: number, prevToCurrentOffsetNormal: P
 }
 
 /**
- * @typedef {Object} PlacedGlyph
- * @property {Point} point The point at which the glyph should be placed, in label plane coordinates
- * @property {number} angle The angle at which the glyph should be placed
- * @property {Array<Point>} path The label-plane path used to reach this glyph: used only for collision detection
+ * Placed Glyph type
  */
 type PlacedGlyph = {
+    /**
+     * The point at which the glyph should be placed, in label plane coordinates
+     */
     point: Point;
+    /**
+     * The angle at which the glyph should be placed
+     */
     angle: number;
+    /**
+     * The label-plane path used to reach this glyph: used only for collision detection
+     */
     path: Array<Point>;
 };
 

package/src/symbol/quads.ts

@@ -2,11 +2,11 @@ import Point from '@mapbox/point-geometry';
 
 import {GLYPH_PBF_BORDER} from '../style/parse_glyph_pbf';
 
-import type Anchor from './anchor';
+import type {Anchor} from './anchor';
 import type {PositionedIcon, Shaping} from './shaping';
 import {SHAPING_DEFAULT_OFFSET} from './shaping';
 import {IMAGE_PADDING} from '../render/image_atlas';
-import type SymbolStyleLayer from '../style/style_layer/symbol_style_layer';
+import type {SymbolStyleLayer} from '../style/style_layer/symbol_style_layer';
 import type {Feature} from '@maplibre/maplibre-gl-style-spec';
 import type {StyleImage} from '../style/style_image';
 import ONE_EM from './one_em';
@@ -17,13 +17,11 @@ import {Rect} from '../render/glyph_atlas';
  *
  * The zoom range the glyph can be shown is defined by minScale and maxScale.
  *
- * @param tl The offset of the top left corner from the anchor.
- * @param tr The offset of the top right corner from the anchor.
- * @param bl The offset of the bottom left corner from the anchor.
- * @param br The offset of the bottom right corner from the anchor.
- * @param tex The texture coordinates.
- *
- * @private
+ * @param tl - The offset of the top left corner from the anchor.
+ * @param tr - The offset of the top right corner from the anchor.
+ * @param bl - The offset of the bottom left corner from the anchor.
+ * @param br - The offset of the bottom right corner from the anchor.
+ * @param tex - The texture coordinates.
  */
 export type SymbolQuad = {
     tl: Point;
@@ -53,7 +51,6 @@ const border = IMAGE_PADDING;
 
 /**
  * Create the quads used for rendering an icon.
- * @private
  */
 export function getIconQuads(
     shapedIcon: PositionedIcon,
@@ -217,7 +214,6 @@ function getPxOffset(fixedOffset, fixedSize, stretchOffset, stretchSize) {
 
 /**
  * Create the quads used for rendering a text label.
- * @private
  */
 export function getGlyphQuads(
     anchor: Anchor,

package/src/symbol/shaping.ts

@@ -3,7 +3,7 @@ import {
     charAllowsIdeographicBreaking,
     charInComplexShapingScript
 } from '../util/script_detection';
-import verticalizePunctuation from '../util/verticalize_punctuation';
+import {verticalizePunctuation} from '../util/verticalize_punctuation';
 import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
 import ONE_EM from './one_em';
 import {warnOnce} from '../util/util';

package/src/symbol/symbol_layout.ts

@@ -1,20 +1,20 @@
-import Anchor from './anchor';
+import {Anchor} from './anchor';
 
 import {getAnchors, getCenterAnchor} from './get_anchors';
-import clipLine from './clip_line';
+import {clipLine} from './clip_line';
 import {shapeText, shapeIcon, WritingMode, fitIconToText} from './shaping';
 import {getGlyphQuads, getIconQuads} from './quads';
-import CollisionFeature from './collision_feature';
+import {CollisionFeature} from './collision_feature';
 import {warnOnce} from '../util/util';
 import {
     allowsVerticalWritingMode,
     allowsLetterSpacing
 } from '../util/script_detection';
-import findPoleOfInaccessibility from '../util/find_pole_of_inaccessibility';
-import classifyRings from '../util/classify_rings';
-import EXTENT from '../data/extent';
-import SymbolBucket from '../data/bucket/symbol_bucket';
-import EvaluationParameters from '../style/evaluation_parameters';
+import {findPoleOfInaccessibility} from '../util/find_pole_of_inaccessibility';
+import {classifyRings} from '../util/classify_rings';
+import {EXTENT} from '../data/extent';
+import {SymbolBucket} from '../data/bucket/symbol_bucket';
+import {EvaluationParameters} from '../style/evaluation_parameters';
 import {SIZE_PACK_FACTOR, MAX_PACKED_SIZE, MAX_GLYPH_ICON_SIZE} from './symbol_size';
 import ONE_EM from './one_em';
 import type {CanonicalTileID} from '../source/tile_id';
@@ -23,7 +23,7 @@ import type {CollisionBoxArray} from '../data/array_types.g';
 import type {SymbolFeature} from '../data/bucket/symbol_bucket';
 import type {StyleImage} from '../style/style_image';
 import type {StyleGlyph} from '../style/style_glyph';
-import type SymbolStyleLayer from '../style/style_layer/symbol_style_layer';
+import type {SymbolStyleLayer} from '../style/style_layer/symbol_style_layer';
 import type {ImagePosition} from '../render/image_atlas';
 import type {GlyphPosition} from '../render/glyph_atlas';
 import type {PossiblyEvaluatedPropertyValue} from '../style/properties';
@@ -364,7 +364,6 @@ export function getAnchorJustification(anchor: TextAnchor): TextJustify {
  * instance' for each _possible_ placement of the symbol feature.
  * (At render timePlaceSymbols#place() selects which of these instances to
  * show or hide based on collisions with symbols in other layers.)
- * @private
  */
 function addFeature(bucket: SymbolBucket,
     feature: SymbolFeature,
@@ -564,8 +563,6 @@ function getDefaultHorizontalShaping(
 
 /**
  * Add a single label & icon placement.
- *
- * @private
  */
 function addSymbol(bucket: SymbolBucket,
     anchor: Anchor,

package/src/symbol/symbol_size.ts

@@ -1,6 +1,6 @@
 import {Interpolate, interpolates} from '@maplibre/maplibre-gl-style-spec';
 import {clamp} from '../util/util';
-import EvaluationParameters from '../style/evaluation_parameters';
+import {EvaluationParameters} from '../style/evaluation_parameters';
 
 import type {PropertyValue, PossiblyEvaluatedPropertyValue} from '../style/properties';
 import type {InterpolationType} from '@maplibre/maplibre-gl-style-spec';

package/src/symbol/symbol_style_layer.test.ts

@@ -1,8 +1,8 @@
-import SymbolStyleLayer from '../style/style_layer/symbol_style_layer';
-import FormatSectionOverride from '../style/format_section_override';
+import {SymbolStyleLayer} from '../style/style_layer/symbol_style_layer';
+import {FormatSectionOverride} from '../style/format_section_override';
 import properties, {SymbolPaintPropsPossiblyEvaluated} from '../style/style_layer/symbol_style_layer_properties.g';
-import ZoomHistory from '../style/zoom_history';
-import EvaluationParameters from '../style/evaluation_parameters';
+import {ZoomHistory} from '../style/zoom_history';
+import {EvaluationParameters} from '../style/evaluation_parameters';
 
 function createSymbolLayer(layerProperties) {
     const layer = new SymbolStyleLayer(layerProperties);

package/src/symbol/transform_text.ts

@@ -1,6 +1,6 @@
 import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
 
-import type SymbolStyleLayer from '../style/style_layer/symbol_style_layer';
+import type {SymbolStyleLayer} from '../style/style_layer/symbol_style_layer';
 import type {Feature} from '@maplibre/maplibre-gl-style-spec';
 import {Formatted} from '@maplibre/maplibre-gl-style-spec';
 
@@ -19,7 +19,7 @@ function transformTextInternal(text: string, layer: SymbolStyleLayer, feature: F
     return text;
 }
 
-export default function transformText(text: Formatted, layer: SymbolStyleLayer, feature: Feature): Formatted {
+export function transformText(text: Formatted, layer: SymbolStyleLayer, feature: Feature): Formatted {
     text.sections.forEach(section => {
         section.text = transformTextInternal(section.text, layer, feature);
     });

package/src/types/callback.ts

@@ -1,15 +1,15 @@
-// Flow can't perfectly type Node-style callbacks yet; it does not have a way to
-// express that if the first parameter is null, the second is not, so for the time
-// being, both parameters must be optional. Use the following convention when defining
-// a callback:
-//
-//    asyncFunction((error, result) => {
-//        if (error) {
-//            // handle error
-//        } else if (result) {
-//            // handle success
-//        }
-//    });
-//
-// See https://github.com/facebook/flow/issues/2123 for more.
+/**
+ * A callback definition.
+ *
+ * @example
+ * ```ts
+ * asyncFunction((error, result) => {
+ *      if (error) {
+ *          // handle error
+ *      } else if (result) {
+ *          // handle success
+ *      }
+ * });
+ * ```
+ */
 export type Callback<T> = (error?: Error | null, result?: T | null) => void;

package/src/types/cancelable.ts

@@ -1,3 +1,6 @@
+/**
+ * A request that can be cancelled
+ */
 export type Cancelable = {
     cancel: () => void;
 };

package/src/types/transferable.ts

@@ -1 +1,4 @@
+/**
+ * An object with is transferable between main and worker thread
+ */
 export type Transferable = ArrayBuffer | MessagePort | ImageBitmap;

package/src/ui/anchor.ts

@@ -1,3 +1,7 @@
+/**
+ * Where to position the anchor.
+ * Used by a popup and a marker.
+ */
 export type PositionAnchor = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
 
 export const anchorTranslate: {