maplibre-gl 3.1.0 → 3.2.0-pre.2

package/src/style/properties.ts

@@ -7,34 +7,20 @@ import {interpolates, Color, StylePropertySpecification, normalizePropertyExpres
     CompositeExpression, TransitionSpecification,
     PropertyValueSpecification} from '@maplibre/maplibre-gl-style-spec';
 import {register} from '../util/web_worker_transfer';
-import EvaluationParameters from './evaluation_parameters';
+import {EvaluationParameters} from './evaluation_parameters';
 
 import {CanonicalTileID} from '../source/tile_id';
 
 type TimePoint = number;
 
+/**
+ * A from-to type
+ */
 export type CrossFaded<T> = {
     to: T;
     from: T;
 };
 
-/**
- * Implements a number of classes that define state and behavior for paint and layout properties, most
- * importantly their respective evaluation chains:
- *
- *       Transitionable paint property value
- *     → Transitioning paint property value
- *     → Possibly evaluated paint property value
- *     → Fully evaluated paint property value
- *
- *       Layout property value
- *     → Possibly evaluated layout property value
- *     → Fully evaluated layout property value
- *
- * @module
- * @private
- */
-
 /**
  *  Implementations of the `Property` interface:
  *
@@ -50,8 +36,6 @@ export type CrossFaded<T> = {
  *  and one for properties that don't. There are a few "special case" implementations as well: one for properties
  *  which cross-fade between two values rather than interpolating, one for `heatmap-color` and `line-gradient`,
  *  and one for `light-position`.
- *
- * @private
  */
 export interface Property<T, R> {
     specification: StylePropertySpecification;
@@ -80,8 +64,6 @@ export interface Property<T, R> {
  *  In addition to storing the original input value, `PropertyValue` also stores a normalized representation,
  *  effectively treating functions as if they are expressions, and constant or default values as if they are
  *  (constant) expressions.
- *
- *  @private
  */
 export class PropertyValue<T, R> {
     property: Property<T, R>;
@@ -107,8 +89,6 @@ export class PropertyValue<T, R> {
     }
 }
 
-// ------- Transitionable -------
-
 export type TransitionParameters = {
     now: TimePoint;
     transition: TransitionSpecification;
@@ -123,8 +103,6 @@ export type TransitionParameters = {
  *
  * A `TransitionablePropertyValue` can calculate the next step in the evaluation chain for paint property values:
  * `TransitioningPropertyValue`.
- *
- * @private
  */
 class TransitionablePropertyValue<T, R> {
     property: Property<T, R>;
@@ -150,8 +128,6 @@ class TransitionablePropertyValue<T, R> {
  * `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.
- *
- * @private
  */
 export class Transitionable<Props> {
     _properties: Properties<Props>;
@@ -219,16 +195,12 @@ export class Transitionable<Props> {
     }
 }
 
-// ------- Transitioning -------
-
 /**
  * `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
  * the new value based on the current time and the configured transition duration and delay. The product is the next
  * step in the evaluation chain: the "possibly evaluated" result type `R`. See below for more on this concept.
- *
- * @private
  */
 class TransitioningPropertyValue<T, R> {
     property: Property<T, R>;
@@ -287,8 +259,6 @@ class TransitioningPropertyValue<T, R> {
  * `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.
- *
- * @private
  */
 export class Transitioning<Props> {
     _properties: Properties<Props>;
@@ -331,8 +301,6 @@ export class Transitioning<Props> {
  * `Layout` stores a map of all (property name, `PropertyValue`) pairs for layout 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.
- *
- * @private
  */
 export class Layout<Props> {
     _properties: Properties<Props>;
@@ -395,8 +363,6 @@ export class Layout<Props> {
  * Note that `PossiblyEvaluatedValue` (and `PossiblyEvaluatedPropertyValue`, below) are _not_ used for properties that
  * do not allow data-driven values. For such properties, we know that the "possibly evaluated" result is always a constant
  * scalar value. See below.
- *
- * @private
  */
 type PossiblyEvaluatedValue<T> = {
     kind: 'constant';
@@ -408,8 +374,6 @@ type PossiblyEvaluatedValue<T> = {
  * `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
  * case where the input value was a constant or camera function.
- *
- * @private
  */
 export class PossiblyEvaluatedPropertyValue<T> {
     property: DataDrivenProperty<T>;
@@ -447,7 +411,6 @@ export class PossiblyEvaluatedPropertyValue<T> {
 /**
  * `PossiblyEvaluated` stores a map of all (property name, `R`) pairs for paint or layout properties of a
  * given layer type.
- * @private
  */
 export class PossiblyEvaluated<Props, PossibleEvaluatedProps> {
     _properties: Properties<Props>;
@@ -467,8 +430,6 @@ export class PossiblyEvaluated<Props, PossibleEvaluatedProps> {
  * 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.
- *
- * @private
  */
 export class DataConstantProperty<T> implements Property<T, T> {
     specification: StylePropertySpecification;
@@ -497,8 +458,6 @@ export class DataConstantProperty<T> implements Property<T, T> {
  * 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.
- *
- * @private
  */
 export class DataDrivenProperty<T> implements Property<T, PossiblyEvaluatedPropertyValue<T>> {
     specification: StylePropertySpecification;
@@ -572,8 +531,6 @@ export class DataDrivenProperty<T> implements Property<T, PossiblyEvaluatedPrope
 /**
  * An implementation of `Property` for  data driven `line-pattern` which are transitioned by cross-fading
  * rather than interpolation.
- *
- * @private
  */
 
 export class CrossFadedDataDrivenProperty<T> extends DataDrivenProperty<CrossFaded<T>> {
@@ -639,8 +596,6 @@ export class CrossFadedDataDrivenProperty<T> extends DataDrivenProperty<CrossFad
 /**
  * An implementation of `Property` for `*-pattern` and `line-dasharray`, which are transitioned by cross-fading
  * rather than interpolation.
- *
- * @private
  */
 export class CrossFadedProperty<T> implements Property<T, CrossFaded<T>> {
     specification: StylePropertySpecification;
@@ -683,8 +638,6 @@ export class CrossFadedProperty<T> implements Property<T, CrossFaded<T>> {
  * 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.
- *
- * @private
  */
 
 export class ColorRampProperty implements Property<Color, boolean> {
@@ -714,8 +667,6 @@ export class ColorRampProperty implements Property<Color, boolean> {
  * on the default value: using `for (const property of Object.keys(this._values))`, they can iterate over
  * only the _own_ properties of `_values`, skipping repeated calculation of transitions and possible/final
  * evaluations for defaults, the result of which will always be the same.
- *
- * @private
  */
 export class Properties<Props> {
     properties: Props;

package/src/style/query_utils.ts

@@ -1,9 +1,9 @@
 import Point from '@mapbox/point-geometry';
 
 import type {PossiblyEvaluatedPropertyValue} from './properties';
-import type StyleLayer from '../style/style_layer';
-import type CircleBucket from '../data/bucket/circle_bucket';
-import type LineBucket from '../data/bucket/line_bucket';
+import type {StyleLayer} from '../style/style_layer';
+import type {CircleBucket} from '../data/bucket/circle_bucket';
+import type {LineBucket} from '../data/bucket/line_bucket';
 
 export function getMaximumPaintValue(
     property: string,

package/src/style/style.test.ts

@@ -1,7 +1,7 @@
-import Style from './style';
-import SourceCache from '../source/source_cache';
-import StyleLayer from './style_layer';
-import Transform from '../geo/transform';
+import {Style} from './style';
+import {SourceCache} from '../source/source_cache';
+import {StyleLayer} from './style_layer';
+import {Transform} from '../geo/transform';
 import {extend} from '../util/util';
 import {RequestManager} from '../util/request_manager';
 import {Event, Evented} from '../util/evented';
@@ -11,14 +11,14 @@ import {
     clearRTLTextPlugin,
     evented as rtlTextPluginEvented
 } from '../source/rtl_text_plugin';
-import browser from '../util/browser';
+import {browser} from '../util/browser';
 import {OverscaledTileID} from '../source/tile_id';
 import {fakeXhr, fakeServer} from 'nise';
 
-import EvaluationParameters from './evaluation_parameters';
+import {EvaluationParameters} from './evaluation_parameters';
 import {LayerSpecification, GeoJSONSourceSpecification, FilterSpecification, SourceSpecification} from '@maplibre/maplibre-gl-style-spec';
 import {SourceClass} from '../source/source';
-import GeoJSONSource from '../source/geojson_source';
+import {GeoJSONSource} from '../source/geojson_source';
 
 function createStyleJSON(properties?) {
     return extend({
@@ -224,6 +224,16 @@ describe('Style#loadURL', () => {
 });
 
 describe('Style#loadJSON', () => {
+    test('serialize() returns undefined until style is loaded', done => {
+        const style = new Style(getStubMap());
+        style.loadJSON(createStyleJSON());
+        expect(style.serialize()).toBeUndefined();
+        style.on('style.load', () => {
+            expect(style.serialize()).toEqual(createStyleJSON());
+            done();
+        });
+    });
+
     test('fires "dataloading" (synchronously)', () => {
         const style = new Style(getStubMap());
         const spy = jest.fn();
@@ -2496,13 +2506,6 @@ describe('Style#query*Features', () => {
 });
 
 describe('Style#addSourceType', () => {
-    const _types = {'existing' () {}};
-
-    jest.spyOn(Style, 'getSourceType').mockImplementation(name => _types[name]);
-    jest.spyOn(Style, 'setSourceType').mockImplementation((name, create) => {
-        _types[name] = create;
-    });
-
     test('adds factory function', done => {
         const style = new Style(getStubMap());
         const sourceType = function () {} as any as SourceClass;
@@ -2514,8 +2517,9 @@ describe('Style#addSourceType', () => {
             }
         };
 
-        style.addSourceType('foo', sourceType, () => {
-            expect(_types['foo']).toBe(sourceType);
+        style.addSourceType('foo', sourceType, (arg1, arg2) => {
+            expect(arg1).toBeNull();
+            expect(arg2).toBeNull();
             done();
         });
     });
@@ -2525,9 +2529,8 @@ describe('Style#addSourceType', () => {
         const sourceType = function () {} as any as SourceClass;
         sourceType.workerSourceURL = 'worker-source.js' as any as URL;
 
-        style.dispatcher.broadcast = function (type, params) {
+        style.dispatcher.broadcast = (type, params) => {
             if (type === 'loadWorkerSource') {
-                expect(_types['bar']).toBe(sourceType);
                 expect(params['name']).toBe('bar');
                 expect(params['url']).toBe('worker-source.js');
                 done();
@@ -2540,7 +2543,7 @@ describe('Style#addSourceType', () => {
     test('refuses to add new type over existing name', done => {
         const style = new Style(getStubMap());
         const sourceType = function () {} as any as SourceClass;
-        style.addSourceType('existing', sourceType, (err) => {
+        style.addSourceType('canvas', sourceType, (err) => {
             expect(err).toBeTruthy();
             done();
         });