maplibre-gl 3.2.1 → 3.2.2

package/src/shaders/symbol_sdf.fragment.glsl.g.ts

@@ -1,2 +1,2 @@
 // This file is generated. Edit build/generate-shaders.ts, then run `npm run codegen`.
-export default '#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float buff=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);buff=(6.0-halo_width/fontScale)/SDF_PX;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(buff-gamma_scaled,buff+gamma_scaled,dist);gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';
+export default '#define SDF_PX 8.0\nuniform bool u_is_halo;uniform sampler2D u_texture;uniform highp float u_gamma_scale;uniform lowp float u_device_pixel_ratio;uniform bool u_is_text;varying vec2 v_data0;varying vec3 v_data1;\n#pragma mapbox: define highp vec4 fill_color\n#pragma mapbox: define highp vec4 halo_color\n#pragma mapbox: define lowp float opacity\n#pragma mapbox: define lowp float halo_width\n#pragma mapbox: define lowp float halo_blur\nvoid main() {\n#pragma mapbox: initialize highp vec4 fill_color\n#pragma mapbox: initialize highp vec4 halo_color\n#pragma mapbox: initialize lowp float opacity\n#pragma mapbox: initialize lowp float halo_width\n#pragma mapbox: initialize lowp float halo_blur\nfloat EDGE_GAMMA=0.105/u_device_pixel_ratio;vec2 tex=v_data0.xy;float gamma_scale=v_data1.x;float size=v_data1.y;float fade_opacity=v_data1[2];float fontScale=u_is_text ? size/24.0 : size;lowp vec4 color=fill_color;highp float gamma=EDGE_GAMMA/(fontScale*u_gamma_scale);lowp float inner_edge=(256.0-64.0)/256.0;if (u_is_halo) {color=halo_color;gamma=(halo_blur*1.19/SDF_PX+EDGE_GAMMA)/(fontScale*u_gamma_scale);inner_edge=inner_edge+gamma*gamma_scale;}lowp float dist=texture2D(u_texture,tex).a;highp float gamma_scaled=gamma*gamma_scale;highp float alpha=smoothstep(inner_edge-gamma_scaled,inner_edge+gamma_scaled,dist);if (u_is_halo) {lowp float halo_edge=(6.0-halo_width/fontScale)/SDF_PX;alpha=min(smoothstep(halo_edge-gamma_scaled,halo_edge+gamma_scaled,dist),1.0-alpha);}gl_FragColor=color*(alpha*opacity*fade_opacity);\n#ifdef OVERDRAW_INSPECTOR\ngl_FragColor=vec4(1.0);\n#endif\n}';

package/src/source/canvas_source.ts

@@ -81,9 +81,7 @@ export class CanvasSource extends ImageSource {
     pause: () => void;
     _playing: boolean;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id: string, options: CanvasSourceSpecification, dispatcher: Dispatcher, eventedParent: Evented) {
         super(id, options, dispatcher, eventedParent);
 

package/src/source/geojson_source.ts

@@ -138,9 +138,7 @@ export class GeoJSONSource extends Evented implements Source {
     _collectResourceTiming: boolean;
     _removed: boolean;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id: string, options: GeoJSONSourceOptions, dispatcher: Dispatcher, eventedParent: Evented) {
         super();
 

package/src/source/image_source.ts

@@ -109,9 +109,7 @@ export class ImageSource extends Evented implements Source {
     _loaded: boolean;
     _request: Cancelable;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(id: string, options: ImageSourceSpecification | VideoSourceSpecification | CanvasSourceSpecification, dispatcher: Dispatcher, eventedParent: Evented) {
         super();
         this.id = id;
@@ -317,7 +315,7 @@ export class ImageSource extends Evented implements Source {
  * Given a list of coordinates, get their center as a coordinate.
  *
  * @returns centerpoint
- * @hidden
+ * @internal
  */
 export function getCoordinatesCenterTileID(coords: Array<MercatorCoordinate>) {
     let minX = Infinity;

package/src/source/source_cache.ts

@@ -25,6 +25,7 @@ import {Terrain} from '../render/terrain';
 import {config} from '../util/config';
 
 /**
+ * @internal
  * `SourceCache` is responsible for
  *
  *  - creating an instance of `Source`

package/src/source/source_state.ts

@@ -6,6 +6,7 @@ export type FeatureStates = {[featureId: string]: FeatureState};
 export type LayerFeatureStates = {[layer: string]: FeatureStates};
 
 /**
+ * @internal
  * SourceFeatureState manages the state and pending changes
  * to features in a source, separated by source layer.
  * stateChanges and deletedStates batch all changes to the tile (updates and removes, respectively)

package/src/source/terrain_source_cache.ts

@@ -8,6 +8,7 @@ import type {SourceCache} from '../source/source_cache';
 import {Terrain} from '../render/terrain';
 
 /**
+ * @internal
  * This class is a helper for the Terrain-class, it:
  *   - loads raster-dem tiles
  *   - manages all renderToTexture tiles.

package/src/source/tile.ts

@@ -47,6 +47,7 @@ import {ExpiryData} from '../util/ajax';
 export type TileState = 'loading' | 'loaded' | 'reloading' | 'unloaded' | 'errored' | 'expired';
 
 /**
+ * @internal
  * A tile object is the combination of a Coordinate, which defines
  * its place, as well as a unique ID and data tracking for its content
  */

package/src/source/tile_cache.ts

@@ -2,10 +2,10 @@ import {OverscaledTileID} from './tile_id';
 import type {Tile} from './tile';
 
 /**
+ * @internal
  * A [least-recently-used cache](http://en.wikipedia.org/wiki/Cache_algorithms)
  * with hash lookup made possible by keeping a list of keys in parallel to
  * an array of dictionary of values
- *
  */
 export class TileCache {
     max: number;

package/src/source/tile_id.ts

@@ -64,6 +64,7 @@ export class CanonicalTileID implements ICanonicalTileID {
 }
 
 /**
+ * @internal
  * An unwrapped tile identifier
  */
 export class UnwrappedTileID {

package/src/source/vector_tile_worker_source.test.ts

@@ -87,6 +87,85 @@ describe('vector tile worker source', () => {
     });
 
     test('VectorTileWorkerSource#loadTile reparses tile if the reloadTile has been called during parsing', (done) => {
+        const rawTileData = new Uint8Array([]);
+        function loadVectorData(params, callback) {
+            return callback(null, {
+                vectorTile: {
+                    layers: {
+                        test: {
+                            version: 2,
+                            name: 'test',
+                            extent: 8192,
+                            length: 1,
+                            feature: (featureIndex: number) => ({
+                                extent: 8192,
+                                type: 1,
+                                id: featureIndex,
+                                properties: {
+                                    name: 'test'
+                                },
+                                loadGeometry () {
+                                    return [[{x: 0, y: 0}]];
+                                }
+                            })
+                        }
+                    }
+                } as any as vt.VectorTile,
+                rawData: rawTileData
+            });
+        }
+
+        const layerIndex = new StyleLayerIndex([{
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'symbol',
+            layout: {
+                'icon-image': 'hello',
+                'text-font': ['StandardFont-Bold'],
+                'text-field': '{name}'
+            }
+        }]);
+
+        const send = jest.fn().mockImplementation((type: string, data: unknown, callback: Function) => {
+            const res = setTimeout(() => callback(null,
+                type === 'getImages' ?
+                    {'hello': {width: 1, height: 1, data: new Uint8Array([0])}} :
+                    {'StandardFont-Bold': {width: 1, height: 1, data: new Uint8Array([0])}}
+            ));
+
+            return {
+                cancel: () => clearTimeout(res)
+            };
+        });
+
+        const actor = {
+            send
+        } as unknown as Actor;
+        const source = new VectorTileWorkerSource(actor, layerIndex, ['hello'], loadVectorData);
+        source.loadTile({
+            source: 'source',
+            uid: 0,
+            tileID: {overscaledZ: 0, wrap: 0, canonical: {x: 0, y: 0, z: 0, w: 0}},
+            request: {url: 'http://localhost:2900/faketile.pbf'}
+        } as any as WorkerTileParameters, () => {
+            done.fail('should not be called');
+        });
+
+        source.reloadTile({
+            source: 'source',
+            uid: '0',
+            tileID: {overscaledZ: 0, wrap: 0, canonical: {x: 0, y: 0, z: 0, w: 0}},
+        } as any as WorkerTileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res).toBeDefined();
+            expect(res.rawTileData).toBeDefined();
+            expect(res.rawTileData).toStrictEqual(rawTileData);
+            done();
+        });
+    });
+
+    test('VectorTileWorkerSource#loadTile reparses tile if reloadTile is called during reparsing', (done) => {
         const rawTileData = new Uint8Array([]);
         function loadVectorData(params, callback) {
             return callback(null, {

package/src/source/vector_tile_worker_source.ts

@@ -24,6 +24,12 @@ export type LoadVectorTileResult = {
     resourceTiming?: Array<PerformanceResourceTiming>;
 } & ExpiryData;
 
+type FetchingState = {
+    rawTileData: ArrayBuffer;
+    cacheControl: ExpiryData;
+    resourceTiming: any;
+}
+
 /**
  * The callback when finished loading vector data
  */
@@ -66,6 +72,7 @@ export class VectorTileWorkerSource implements WorkerSource {
     layerIndex: StyleLayerIndex;
     availableImages: Array<string>;
     loadVectorData: LoadVectorData;
+    fetching: {[_: string]: FetchingState };
     loading: {[_: string]: WorkerTile};
     loaded: {[_: string]: WorkerTile};
 
@@ -80,6 +87,7 @@ export class VectorTileWorkerSource implements WorkerSource {
         this.layerIndex = layerIndex;
         this.availableImages = availableImages;
         this.loadVectorData = loadVectorData || loadVectorTile;
+        this.fetching = {};
         this.loading = {};
         this.loaded = {};
     }
@@ -124,6 +132,7 @@ export class VectorTileWorkerSource implements WorkerSource {
 
             workerTile.vectorTile = response.vectorTile;
             workerTile.parse(response.vectorTile, this.layerIndex, this.availableImages, this.actor, (err, result) => {
+                delete this.fetching[uid];
                 if (err || !result) return callback(err);
 
                 // Transferring a copy of rawTileData because the worker needs to retain its copy.
@@ -132,6 +141,8 @@ export class VectorTileWorkerSource implements WorkerSource {
 
             this.loaded = this.loaded || {};
             this.loaded[uid] = workerTile;
+            // keep the original fetching state so that reload tile can pick it up if the original parse is cancelled by reloads' parse
+            this.fetching[uid] = {rawTileData, cacheControl, resourceTiming};
         }) as AbortVectorData;
     }
 
@@ -145,7 +156,21 @@ export class VectorTileWorkerSource implements WorkerSource {
             const workerTile = loaded[uid];
             workerTile.showCollisionBoxes = params.showCollisionBoxes;
             if (workerTile.status === 'parsing') {
-                workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, callback);
+                workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, (err, result) => {
+                    if (err || !result) return callback(err, result);
+
+                    // if we have cancelled the original parse, make sure to pass the rawTileData from the original fetch
+                    let parseResult;
+                    if (this.fetching[uid]) {
+                        const {rawTileData, cacheControl, resourceTiming} = this.fetching[uid];
+                        delete this.fetching[uid];
+                        parseResult = extend({rawTileData: rawTileData.slice(0)}, result, cacheControl, resourceTiming);
+                    } else {
+                        parseResult = result;
+                    }
+
+                    callback(null, parseResult);
+                });
             } else if (workerTile.status === 'done') {
                 // if there was no vector tile data on the initial load, don't try and re-parse tile
                 if (workerTile.vectorTile) {

package/src/source/worker_source.ts

@@ -41,6 +41,7 @@ export type WorkerDEMTileParameters = TileParameters & {
 };
 
 /**
+ * @internal
  * The worker tile's result type
  */
 export type WorkerTileResult = {

package/src/style/evaluation_parameters.ts

@@ -11,6 +11,7 @@ export type CrossfadeParameters = {
 };
 
 /**
+ * @internal
  * A parameter that can be evaluated to a value
  */
 export class EvaluationParameters {

package/src/style/properties.ts

@@ -22,6 +22,7 @@ export type CrossFaded<T> = {
 };
 
 /**
+ * @internal
  *  Implementations of the `Property` interface:
  *
  *  * Hold metadata about a property that's independent of any specific value: stuff like the type of the value,
@@ -49,6 +50,7 @@ export interface Property<T, R> {
 }
 
 /**
+ * @internal
  *  `PropertyValue` represents the value part of a property key-value unit. It's used to represent both
  *  paint and layout property values, and regardless of whether or not their property supports data-driven
  *  expressions.
@@ -95,6 +97,7 @@ export type TransitionParameters = {
 };
 
 /**
+ * @internal
  * Paint properties are _transitionable_: they can change in a fluid manner, interpolating or cross-fading between
  * old and new value. The duration of the transition, and the delay before it begins, is configurable.
  *
@@ -125,6 +128,7 @@ class TransitionablePropertyValue<T, R> {
 }
 
 /**
+ * @internal
  * `Transitionable` stores a map of all (property name, `TransitionablePropertyValue`) pairs for paint properties of a
  * given layer type. It can calculate the `TransitioningPropertyValue`s for all of them at once, producing a
  * `Transitioning` instance for the same set of properties.
@@ -196,6 +200,7 @@ export class Transitionable<Props> {
 }
 
 /**
+ * @internal
  * `TransitioningPropertyValue` implements the first of two intermediate steps in the evaluation chain of a paint
  * property value. In this step, transitions between old and new values are handled: as long as the transition is in
  * progress, `TransitioningPropertyValue` maintains a reference to the prior value, and interpolates between it and
@@ -256,6 +261,7 @@ class TransitioningPropertyValue<T, R> {
 }
 
 /**
+ * @internal
  * `Transitioning` stores a map of all (property name, `TransitioningPropertyValue`) pairs for paint properties of a
  * given layer type. It can calculate the possibly-evaluated values for all of them at once, producing a
  * `PossiblyEvaluated` instance for the same set of properties.
@@ -370,6 +376,7 @@ type PossiblyEvaluatedValue<T> = {
 } | SourceExpression | CompositeExpression;
 
 /**
+ * @internal
  * `PossiblyEvaluatedPropertyValue` is used for data-driven paint and layout property values. It holds a
  * `PossiblyEvaluatedValue` and the `GlobalProperties` that were used to generate it. You're not allowed to supply
  * a different set of `GlobalProperties` when performing the final evaluation because they would be ignored in the
@@ -409,6 +416,7 @@ export class PossiblyEvaluatedPropertyValue<T> {
 }
 
 /**
+ * @internal
  * `PossiblyEvaluated` stores a map of all (property name, `R`) pairs for paint or layout properties of a
  * given layer type.
  */
@@ -427,6 +435,7 @@ export class PossiblyEvaluated<Props, PossibleEvaluatedProps> {
 }
 
 /**
+ * @internal
  * An implementation of `Property` for properties that do not permit data-driven (source or composite) expressions.
  * This restriction allows us to declare statically that the result of possibly evaluating this kind of property
  * is in fact always the scalar type `T`, and can be used without further evaluating the value on a per-feature basis.
@@ -455,6 +464,7 @@ export class DataConstantProperty<T> implements Property<T, T> {
 }
 
 /**
+ * @internal
  * An implementation of `Property` for properties that permit data-driven (source or composite) expressions.
  * The result of possibly evaluating this kind of property is `PossiblyEvaluatedPropertyValue<T>`; obtaining
  * a scalar value `T` requires further evaluation on a per-feature basis.
@@ -529,6 +539,7 @@ export class DataDrivenProperty<T> implements Property<T, PossiblyEvaluatedPrope
 }
 
 /**
+ * @internal
  * An implementation of `Property` for  data driven `line-pattern` which are transitioned by cross-fading
  * rather than interpolation.
  */
@@ -594,6 +605,7 @@ export class CrossFadedDataDrivenProperty<T> extends DataDrivenProperty<CrossFad
     }
 }
 /**
+ * @internal
  * An implementation of `Property` for `*-pattern` and `line-dasharray`, which are transitioned by cross-fading
  * rather than interpolation.
  */
@@ -635,6 +647,7 @@ export class CrossFadedProperty<T> implements Property<T, CrossFaded<T>> {
 }
 
 /**
+ * @internal
  * An implementation of `Property` for `heatmap-color` and `line-gradient`. Interpolation is a no-op, and
  * evaluation returns a boolean value in order to indicate its presence, but the real
  * evaluation happens in StyleLayer classes.
@@ -660,6 +673,7 @@ export class ColorRampProperty implements Property<Color, boolean> {
 }
 
 /**
+ * @internal
  * `Properties` holds objects containing default values for the layout or paint property set of a given
  * layer type. These objects are immutable, and they are used as the prototypes for the `_values` members of
  * `Transitionable`, `Transitioning`, `Layout`, and `PossiblyEvaluated`. This allows these classes to avoid

package/src/style/style.ts

@@ -562,6 +562,7 @@ export class Style extends Evented {
     }
 
     /**
+     * @internal
      * Apply queued style updates in a batch and recalculate zoom-dependent paint properties.
      */
     update(parameters: EvaluationParameters) {

package/src/style/style_glyph.ts

@@ -12,6 +12,7 @@ export type GlyphMetrics = {
 };
 
 /**
+ * @internal
  * A style glyph type
  */
 export type StyleGlyph = {

package/src/symbol/collision_index.ts

@@ -33,6 +33,7 @@ export type FeatureKey = {
 };
 
 /**
+ * @internal
  * A collision index used to prevent symbols from overlapping. It keep tracks of
  * where previous symbols have been placed and is used to check if a new
  * symbol overlaps with any previously added symbols.

package/src/symbol/grid_index.ts

@@ -48,6 +48,7 @@ function overlapAllowed(overlapA: OverlapMode, overlapB: OverlapMode): boolean {
 }
 
 /**
+ * @internal
  * GridIndex is a data structure for testing the intersection of
  * circles and rectangles in a 2d plane.
  * It is optimized for rapid insertion and querying.

package/src/ui/camera.ts

@@ -263,30 +263,30 @@ export abstract class Camera extends Evented {
     _easeFrameId: TaskID;
 
     /**
-     * @hidden
+     * @internal
      * holds the geographical coordinate of the target
      */
     _elevationCenter: LngLat;
     /**
-     * @hidden
+     * @internal
      * holds the targ altitude value, = center elevation of the target.
      * This value may changes during flight, because new terrain-tiles loads during flight.
      */
     _elevationTarget: number;
     /**
-     * @hidden
+     * @internal
      * holds the start altitude value, = center elevation before animation begins
      * this value will recalculated during flight in respect of changing _elevationTarget values,
      * so the linear interpolation between start and target keeps smooth and without jumps.
      */
     _elevationStart: number;
     /**
-     * @hidden
+     * @internal
      * Saves the current state of the elevation freeze - this is used during map movement to prevent "rocky" camera movement.
      */
     _elevationFreeze: boolean;
     /**
-     * @hidden
+     * @internal
      * Used to track accumulated changes during continuous interaction
      */
     _requestedCameraState?: Transform;
@@ -645,6 +645,7 @@ export abstract class Camera extends Evented {
     }
 
     /**
+     * @internal
      * Calculate the center of these two points in the viewport and use
      * the highest zoom level up to and including `Map#getMaxZoom()` that fits
      * the points in the viewport at the specified bearing.
@@ -654,7 +655,6 @@ export abstract class Camera extends Evented {
      * @param options - the camera options
      * @returns If map is able to fit to provided bounds, returns `center`, `zoom`, and `bearing`.
      *      If map is unable to fit, method will warn and return undefined.
-     * @hidden
      * @example
      * ```ts
      * let p0 = [-79, 43];
@@ -1085,11 +1085,11 @@ export abstract class Camera extends Evented {
     }
 
     /**
+     * @internal
      * Called when the camera is about to be manipulated.
      * If `transformCameraUpdate` is specified, a copy of the current transform is created to track the accumulated changes.
      * This underlying transform represents the "desired state" proposed by input handlers / animations / UI controls.
      * It may differ from the state used for rendering (`this.transform`).
-     * @hidden
      * @returns Transform to apply changes to
      */
     _getTransformForUpdate(): Transform {
@@ -1102,8 +1102,8 @@ export abstract class Camera extends Evented {
     }
 
     /**
+     * @internal
      * Called after the camera is done being manipulated.
-     * @hidden
      * @param tr - the requested camera end state
      * Call `transformCameraUpdate` if present, and then apply the "approved" changes.
      */

package/src/ui/handler/box_zoom.ts

@@ -25,9 +25,7 @@ export class BoxZoomHandler implements Handler {
     _box: HTMLElement;
     _clickTolerance: number;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(map: Map, options: {
         clickTolerance: number;
     }) {

package/src/ui/handler/click_zoom.ts

@@ -13,9 +13,7 @@ export class ClickZoomHandler implements Handler {
     _enabled: boolean;
     _active: boolean;
 
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(map: Map) {
         this._tr = new TransformProvider(map);
         this.reset();

package/src/ui/handler/keyboard.ts

@@ -33,9 +33,7 @@ export class KeyboardHandler implements Handler {
     _pitchStep: number;
     _rotationDisabled: boolean;
 
-    /**
-    * @hidden
-    */
+    /** @internal */
     constructor(map: Map) {
         this._tr = new TransformProvider(map);
         const stepOptions = defaultOptions;

package/src/ui/handler/scroll_zoom.ts

@@ -62,9 +62,7 @@ export class ScrollZoomHandler implements Handler {
     _defaultZoomRate: number;
     _wheelZoomRate: number;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor(map: Map, triggerRenderFrame: () => void) {
         this._map = map;
         this._tr = new TransformProvider(map);

package/src/ui/handler/shim/dblclick_zoom.ts

@@ -12,9 +12,7 @@ export class DoubleClickZoomHandler {
     _clickZoom: ClickZoomHandler;
     _tapZoom: TapZoomHandler;
 
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(clickZoom: ClickZoomHandler, TapZoom: TapZoomHandler) {
         this._clickZoom = clickZoom;
         this._tapZoom = TapZoom;

package/src/ui/handler/shim/drag_pan.ts

@@ -41,9 +41,7 @@ export class DragPanHandler {
     _touchPan: TouchPanHandler;
     _inertiaOptions: DragPanOptions | boolean;
 
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(el: HTMLElement, mousePan: MousePanHandler, touchPan: TouchPanHandler) {
         this._el = el;
         this._mousePan = mousePan;

package/src/ui/handler/shim/drag_rotate.ts

@@ -20,9 +20,7 @@ export class DragRotateHandler {
     _mousePitch: MousePitchHandler;
     _pitchWithRotate: boolean;
 
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(options: DragRotateHandlerOptions, mouseRotate: MouseRotateHandler, mousePitch: MousePitchHandler) {
         this._pitchWithRotate = options.pitchWithRotate;
         this._mouseRotate = mouseRotate;

package/src/ui/handler/shim/two_fingers_touch.ts

@@ -19,9 +19,7 @@ export class TwoFingersTouchZoomRotateHandler {
     _rotationDisabled: boolean;
     _enabled: boolean;
 
-    /**
-     * @hidden
-    */
+    /** @internal */
     constructor(el: HTMLElement, touchZoom: TwoFingersTouchZoomHandler, touchRotate: TwoFingersTouchRotateHandler, tapDragZoom: TapDragZoomHandler) {
         this._el = el;
         this._touchZoom = touchZoom;

package/src/ui/handler/transform-provider.ts

@@ -5,6 +5,7 @@ import Point from '@mapbox/point-geometry';
 import {LngLat} from '../../geo/lng_lat';
 
 /**
+ * @internal
  * Shared utilities for the Handler classes to access the correct camera state.
  * If Camera.transformCameraUpdate is specified, the "desired state" of camera may differ from the state used for rendering.
  * The handlers need the "desired state" to track accumulated changes.

package/src/ui/handler/two_fingers_touch.ts

@@ -27,9 +27,7 @@ abstract class TwoFingersTouchHandler implements Handler {
     _startVector: Point;
     _aroundCenter: boolean;
 
-    /**
-     * @hidden
-     */
+    /** @internal */
     constructor() {
         this.reset();
     }