maplibre-gl 3.2.0 → 3.2.2

package/src/source/vector_tile_worker_source.test.ts

@@ -6,7 +6,7 @@ import {VectorTileWorkerSource} from '../source/vector_tile_worker_source';
 import {StyleLayerIndex} from '../style/style_layer_index';
 import {fakeServer, FakeServer} from 'nise';
 import {Actor} from '../util/actor';
-import {TileParameters, WorkerTileParameters} from './worker_source';
+import {TileParameters, WorkerTileParameters, WorkerTileResult} from './worker_source';
 import {WorkerTile} from './worker_tile';
 import {setPerformance} from '../util/test/util';
 
@@ -18,7 +18,6 @@ describe('vector tile worker source', () => {
         global.fetch = null;
         server = fakeServer.create();
         setPerformance();
-
     });
 
     afterEach(() => {
@@ -87,83 +86,133 @@ describe('vector tile worker source', () => {
         expect(callback).toHaveBeenCalledTimes(1);
     });
 
-    test('VectorTileWorkerSource#reloadTile queues a reload when parsing is in progress', () => {
-        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
-        const parse = jest.fn();
+    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
+            });
+        }
 
-        source.loaded = {
-            '0': {
-                status: 'done',
-                vectorTile: {},
-                parse
-            } as any as WorkerTile
-        };
+        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 callback1 = jest.fn();
-        const callback2 = jest.fn();
-        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback1);
-        expect(parse).toHaveBeenCalledTimes(1);
+        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])}}
+            ));
 
-        source.loaded[0].status = 'parsing';
-        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback2);
-        expect(parse).toHaveBeenCalledTimes(1);
+            return {
+                cancel: () => clearTimeout(res)
+            };
+        });
 
-        parse.mock.calls[0][4]();
-        expect(parse).toHaveBeenCalledTimes(2);
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(0);
+        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');
+        });
 
-        parse.mock.calls[1][4]();
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(1);
+        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#reloadTile handles multiple pending reloads', () => {
-        // https://github.com/mapbox/mapbox-gl-js/issues/6308
-        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
-        const parse = jest.fn();
+    test('VectorTileWorkerSource#loadTile reparses tile if reloadTile is called during reparsing', (done) => {
+        const rawTileData = new Uint8Array([]);
+        function loadVectorData(params, callback) {
+            return callback(null, {
+                vectorTile: new vt.VectorTile(new Protobuf(rawTileData)),
+                rawData: rawTileData
+            });
+        }
 
-        source.loaded = {
-            '0': {
-                status: 'done',
-                vectorTile: {},
-                parse
-            } as any as WorkerTile
-        };
+        const layerIndex = new StyleLayerIndex([{
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'fill'
+        }]);
 
-        const callback1 = jest.fn();
-        const callback2 = jest.fn();
-        const callback3 = jest.fn();
-        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback1);
-        expect(parse).toHaveBeenCalledTimes(1);
+        const source = new VectorTileWorkerSource(actor, layerIndex, [], loadVectorData);
 
-        source.loaded[0].status = 'parsing';
-        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback2);
-        expect(parse).toHaveBeenCalledTimes(1);
+        const parseWorkerTileMock = jest
+            .spyOn(WorkerTile.prototype, 'parse')
+            .mockImplementation(function(data, layerIndex, availableImages, actor, callback) {
+                this.status = 'parsing';
+                window.setTimeout(() => callback(null, {} as WorkerTileResult), 10);
+            });
 
-        parse.mock.calls[0][4]();
-        expect(parse).toHaveBeenCalledTimes(2);
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(0);
-        expect(callback3).toHaveBeenCalledTimes(0);
-
-        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback3);
-        expect(parse).toHaveBeenCalledTimes(2);
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(0);
-        expect(callback3).toHaveBeenCalledTimes(0);
-
-        parse.mock.calls[1][4]();
-        expect(parse).toHaveBeenCalledTimes(3);
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(1);
-        expect(callback3).toHaveBeenCalledTimes(0);
-
-        parse.mock.calls[2][4]();
-        expect(callback1).toHaveBeenCalledTimes(1);
-        expect(callback2).toHaveBeenCalledTimes(1);
-        expect(callback3).toHaveBeenCalledTimes(1);
+        let loadCallbackCalled = false;
+        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, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res).toBeDefined();
+            loadCallbackCalled = true;
+        });
 
+        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(parseWorkerTileMock).toHaveBeenCalledTimes(2);
+            expect(loadCallbackCalled).toBeTruthy();
+            done();
+        });
     });
 
     test('VectorTileWorkerSource#reloadTile does not reparse tiles with no vectorTile data but does call callback', () => {

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;
     }
 
@@ -139,30 +150,33 @@ export class VectorTileWorkerSource implements WorkerSource {
      * Implements {@link WorkerSource#reloadTile}.
      */
     reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback) {
-        const loaded = this.loaded,
-            uid = params.uid,
-            vtSource = this;
+        const loaded = this.loaded;
+        const uid = params.uid;
         if (loaded && loaded[uid]) {
             const workerTile = loaded[uid];
             workerTile.showCollisionBoxes = params.showCollisionBoxes;
-
-            const done = (err?: Error, data?: any) => {
-                const reloadCallback = workerTile.reloadCallback;
-                if (reloadCallback) {
-                    delete workerTile.reloadCallback;
-                    workerTile.parse(workerTile.vectorTile, vtSource.layerIndex, this.availableImages, vtSource.actor, reloadCallback);
-                }
-                callback(err, data);
-            };
-
             if (workerTile.status === 'parsing') {
-                workerTile.reloadCallback = done;
+                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) {
-                    workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, done);
+                    workerTile.parse(workerTile.vectorTile, this.layerIndex, this.availableImages, this.actor, callback);
                 } else {
-                    done();
+                    callback();
                 }
             }
         }

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/source/worker_tile.test.ts

@@ -99,4 +99,147 @@ describe('worker tile', () => {
             done();
         });
     });
+
+    test('WorkerTile#parse would request all types of dependencies', done => {
+        const tile = createWorkerTile();
+        const layerIndex = new StyleLayerIndex([{
+            id: '1',
+            type: 'fill',
+            source: 'source',
+            'source-layer': 'test',
+            paint: {
+                'fill-pattern': 'hello'
+            }
+        }, {
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'symbol',
+            layout: {
+                'icon-image': 'hello',
+                'text-font': ['StandardFont-Bold'],
+                'text-field': '{name}'
+            }
+        }]);
+
+        const data = {
+            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 VectorTile;
+
+        const send = jest.fn().mockImplementation((type: string, data: unknown, callback: Function) => {
+            setTimeout(() => callback(null,
+                type === 'getImages' ?
+                    {'hello': {width: 1, height: 1, data: new Uint8Array([0])}} :
+                    {'StandardFont-Bold': {width: 1, height: 1, data: new Uint8Array([0])}}
+            ));
+        });
+
+        const actorMock = {
+            send
+        } as unknown as Actor;
+        tile.parse(data, layerIndex, ['hello'], actorMock, (err, result) => {
+            expect(err).toBeFalsy();
+            expect(result).toBeDefined();
+            expect(send).toHaveBeenCalledTimes(3);
+            expect(send).toHaveBeenCalledWith('getImages', expect.objectContaining({'icons': ['hello'], 'type': 'icons'}), expect.any(Function));
+            expect(send).toHaveBeenCalledWith('getImages', expect.objectContaining({'icons': ['hello'], 'type': 'patterns'}), expect.any(Function));
+            expect(send).toHaveBeenCalledWith('getGlyphs', expect.objectContaining({'source': 'source', 'type': 'glyphs', 'stacks': {'StandardFont-Bold': [101, 115, 116]}}), expect.any(Function));
+            done();
+        });
+    });
+
+    test('WorkerTile#parse would cancel and only event once on repeated reparsing', done => {
+        const tile = createWorkerTile();
+        const layerIndex = new StyleLayerIndex([{
+            id: '1',
+            type: 'fill',
+            source: 'source',
+            'source-layer': 'test',
+            paint: {
+                'fill-pattern': 'hello'
+            }
+        }, {
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'symbol',
+            layout: {
+                'icon-image': 'hello',
+                'text-font': ['StandardFont-Bold'],
+                'text-field': '{name}'
+            }
+        }]);
+
+        const data = {
+            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 VectorTile;
+
+        let cancelCount = 0;
+        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: () => {
+                    cancelCount += 1;
+                    clearTimeout(res);
+                }
+            };
+        });
+
+        const actorMock = {
+            send
+        } as unknown as Actor;
+        tile.parse(data, layerIndex, ['hello'], actorMock, () => done.fail('should not be called'));
+        tile.parse(data, layerIndex, ['hello'], actorMock, () => done.fail('should not be called'));
+        tile.parse(data, layerIndex, ['hello'], actorMock, (err, result) => {
+            expect(err).toBeFalsy();
+            expect(result).toBeDefined();
+            expect(cancelCount).toBe(6);
+            expect(send).toHaveBeenCalledTimes(9);
+            expect(send).toHaveBeenCalledWith('getImages', expect.objectContaining({'icons': ['hello'], 'type': 'icons'}), expect.any(Function));
+            expect(send).toHaveBeenCalledWith('getImages', expect.objectContaining({'icons': ['hello'], 'type': 'patterns'}), expect.any(Function));
+            expect(send).toHaveBeenCalledWith('getGlyphs', expect.objectContaining({'source': 'source', 'type': 'glyphs', 'stacks': {'StandardFont-Bold': [101, 115, 116]}}), expect.any(Function));
+            done();
+        });
+    });
 });

package/src/source/worker_tile.ts

@@ -24,6 +24,7 @@ import type {
 } from '../source/worker_source';
 import type {PromoteIdSpecification} from '@maplibre/maplibre-gl-style-spec';
 import type {VectorTile} from '@mapbox/vector-tile';
+import {Cancelable} from '../types/cancelable';
 
 export class WorkerTile {
     tileID: OverscaledTileID;
@@ -43,8 +44,9 @@ export class WorkerTile {
     collisionBoxArray: CollisionBoxArray;
 
     abort: (() => void);
-    reloadCallback: WorkerTileCallback;
     vectorTile: VectorTile;
+    inFlightDependencies: Cancelable[];
+    dependencySentinel: number;
 
     constructor(params: WorkerTileParameters) {
         this.tileID = new OverscaledTileID(params.tileID.overscaledZ, params.tileID.wrap, params.tileID.canonical.z, params.tileID.canonical.x, params.tileID.canonical.y);
@@ -58,6 +60,8 @@ export class WorkerTile {
         this.collectResourceTiming = !!params.collectResourceTiming;
         this.returnDependencies = !!params.returnDependencies;
         this.promoteId = params.promoteId;
+        this.inFlightDependencies = [];
+        this.dependencySentinel = -1;
     }
 
     parse(data: VectorTile, layerIndex: StyleLayerIndex, availableImages: Array<string>, actor: Actor, callback: WorkerTileCallback) {
@@ -138,40 +142,55 @@ export class WorkerTile {
         let patternMap: {[_: string]: StyleImage};
 
         const stacks = mapObject(options.glyphDependencies, (glyphs) => Object.keys(glyphs).map(Number));
+
+        this.inFlightDependencies.forEach((request) => request?.cancel());
+        this.inFlightDependencies = [];
+
+        // cancelling seems to be not sufficient, we seems to still manage to get a callback hit, so use a sentinel to drop stale results
+        const dependencySentinel = ++this.dependencySentinel;
         if (Object.keys(stacks).length) {
-            actor.send('getGlyphs', {uid: this.uid, stacks, source: this.source, tileID: this.tileID, type: 'glyphs'}, (err, result) => {
+            this.inFlightDependencies.push(actor.send('getGlyphs', {uid: this.uid, stacks, source: this.source, tileID: this.tileID, type: 'glyphs'}, (err, result) => {
+                if (dependencySentinel !== this.dependencySentinel) {
+                    return;
+                }
                 if (!error) {
                     error = err;
                     glyphMap = result;
                     maybePrepare.call(this);
                 }
-            });
+            }));
         } else {
             glyphMap = {};
         }
 
         const icons = Object.keys(options.iconDependencies);
         if (icons.length) {
-            actor.send('getImages', {icons, source: this.source, tileID: this.tileID, type: 'icons'}, (err, result) => {
+            this.inFlightDependencies.push(actor.send('getImages', {icons, source: this.source, tileID: this.tileID, type: 'icons'}, (err, result) => {
+                if (dependencySentinel !== this.dependencySentinel) {
+                    return;
+                }
                 if (!error) {
                     error = err;
                     iconMap = result;
                     maybePrepare.call(this);
                 }
-            });
+            }));
         } else {
             iconMap = {};
         }
 
         const patterns = Object.keys(options.patternDependencies);
         if (patterns.length) {
-            actor.send('getImages', {icons: patterns, source: this.source, tileID: this.tileID, type: 'patterns'}, (err, result) => {
+            this.inFlightDependencies.push(actor.send('getImages', {icons: patterns, source: this.source, tileID: this.tileID, type: 'patterns'}, (err, result) => {
+                if (dependencySentinel !== this.dependencySentinel) {
+                    return;
+                }
                 if (!error) {
                     error = err;
                     patternMap = result;
                     maybePrepare.call(this);
                 }
-            });
+            }));
         } else {
             patternMap = {};
         }

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