maplibre-gl 2.0.5 → 2.1.3

package/src/source/worker.ts

@@ -31,21 +31,21 @@ export default class Worker {
     layerIndexes: {[_: string]: StyleLayerIndex};
     availableImages: {[_: string]: Array<string>};
     workerSourceTypes: {
-      [_: string]: {
-        new (...args: any): WorkerSource;
-      };
+        [_: string]: {
+            new (...args: any): WorkerSource;
+        };
     };
     workerSources: {
-      [_: string]: {
         [_: string]: {
-          [_: string]: WorkerSource;
+            [_: string]: {
+                [_: string]: WorkerSource;
+            };
         };
-      };
     };
     demWorkerSources: {
-      [_: string]: {
-        [_: string]: RasterDEMTileWorkerSource;
-      };
+        [_: string]: {
+            [_: string]: RasterDEMTileWorkerSource;
+        };
     };
     referrer: string;
 
@@ -66,7 +66,7 @@ export default class Worker {
         this.demWorkerSources = {};
 
         this.self.registerWorkerSource = (name: string, WorkerSource: {
-          new (...args: any): WorkerSource;
+            new (...args: any): WorkerSource;
         }) => {
             if (this.workerSourceTypes[name]) {
                 throw new Error(`Worker source with name "${name}" already registered.`);
@@ -76,9 +76,9 @@ export default class Worker {
 
         // This is invoked by the RTL text plugin when the download via the `importScripts` call has finished, and the code has been parsed.
         this.self.registerRTLTextPlugin = (rtlTextPlugin: {
-          applyArabicShaping: Function;
-          processBidirectionalText: ((b: string, a: Array<number>) => Array<string>);
-          processStyledBidirectionalText?: ((c: string, b: Array<number>, a: Array<number>) => Array<[string, Array<number>]>);
+            applyArabicShaping: Function;
+            processBidirectionalText: ((b: string, a: Array<number>) => Array<string>);
+            processStyledBidirectionalText?: ((c: string, b: Array<number>, a: Array<number>) => Array<[string, Array<number>]>);
         }) => {
             if (globalRTLTextPlugin.isParsed()) {
                 throw new Error('RTL text plugin already registered.');
@@ -110,15 +110,15 @@ export default class Worker {
     }
 
     updateLayers(mapId: string, params: {
-      layers: Array<LayerSpecification>;
-      removedIds: Array<string>;
+        layers: Array<LayerSpecification>;
+        removedIds: Array<string>;
     }, callback: WorkerTileCallback) {
         this.getLayerIndex(mapId).update(params.layers, params.removedIds);
         callback();
     }
 
     loadTile(mapId: string, params: WorkerTileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).loadTile(params, callback);
@@ -129,21 +129,21 @@ export default class Worker {
     }
 
     reloadTile(mapId: string, params: WorkerTileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).reloadTile(params, callback);
     }
 
     abortTile(mapId: string, params: TileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).abortTile(params, callback);
     }
 
     removeTile(mapId: string, params: TileParameters & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         this.getWorkerSource(mapId, params.type, params.source).removeTile(params, callback);
@@ -154,9 +154,9 @@ export default class Worker {
     }
 
     removeSource(mapId: string, params: {
-      source: string;
+        source: string;
     } & {
-      type: string;
+        type: string;
     }, callback: WorkerTileCallback) {
         assert(params.type);
         assert(params.source);
@@ -184,7 +184,7 @@ export default class Worker {
      *  @private
      */
     loadWorkerSource(map: string, params: {
-      url: string;
+        url: string;
     }, callback: Callback<void>) {
         try {
             this.self.importScripts(params.url);

package/src/source/worker_source.ts

@@ -5,59 +5,59 @@ import type ImageAtlas from '../render/image_atlas';
 import type {OverscaledTileID} from './tile_id';
 import type {Bucket} from '../data/bucket';
 import type FeatureIndex from '../data/feature_index';
-import type {CollisionBoxArray} from '../data/array_types';
+import type {CollisionBoxArray} from '../data/array_types.g';
 import type DEMData from '../data/dem_data';
 import type {StyleGlyph} from '../style/style_glyph';
 import type {StyleImage} from '../style/style_image';
 import type {PromoteIdSpecification} from '../style-spec/types';
 
 export type TileParameters = {
-  source: string;
-  uid: string;
+    source: string;
+    uid: string;
 };
 
 export type WorkerTileParameters = TileParameters & {
-  tileID: OverscaledTileID;
-  request: RequestParameters;
-  zoom: number;
-  maxZoom: number;
-  tileSize: number;
-  promoteId: PromoteIdSpecification;
-  pixelRatio: number;
-  showCollisionBoxes: boolean;
-  collectResourceTiming?: boolean;
-  returnDependencies?: boolean;
+    tileID: OverscaledTileID;
+    request: RequestParameters;
+    zoom: number;
+    maxZoom: number;
+    tileSize: number;
+    promoteId: PromoteIdSpecification;
+    pixelRatio: number;
+    showCollisionBoxes: boolean;
+    collectResourceTiming?: boolean;
+    returnDependencies?: boolean;
 };
 
 export type WorkerDEMTileParameters = TileParameters & {
-  coord: {
-    z: number;
-    x: number;
-    y: number;
-    w: number;
-  };
-  rawImageData: RGBAImage | ImageBitmap;
-  encoding: 'mapbox' | 'terrarium';
+    coord: {
+        z: number;
+        x: number;
+        y: number;
+        w: number;
+    };
+    rawImageData: RGBAImage | ImageBitmap;
+    encoding: 'mapbox' | 'terrarium';
 };
 
 export type WorkerTileResult = {
-  buckets: Array<Bucket>;
-  imageAtlas: ImageAtlas;
-  glyphAtlasImage: AlphaImage;
-  featureIndex: FeatureIndex;
-  collisionBoxArray: CollisionBoxArray;
-  rawTileData?: ArrayBuffer;
-  resourceTiming?: Array<PerformanceResourceTiming>;
-  // Only used for benchmarking:
-  glyphMap?: {
-    [_: string]: {
-      [_: number]: StyleGlyph;
-    };
-  } | null;
-  iconMap?: {
-    [_: string]: StyleImage;
-  } | null;
-  glyphPositions?: GlyphPositions | null;
+    buckets: Array<Bucket>;
+    imageAtlas: ImageAtlas;
+    glyphAtlasImage: AlphaImage;
+    featureIndex: FeatureIndex;
+    collisionBoxArray: CollisionBoxArray;
+    rawTileData?: ArrayBuffer;
+    resourceTiming?: Array<PerformanceResourceTiming>;
+    // Only used for benchmarking:
+    glyphMap?: {
+        [_: string]: {
+            [_: number]: StyleGlyph;
+        };
+    } | null;
+    iconMap?: {
+        [_: string]: StyleImage;
+    } | null;
+    glyphPositions?: GlyphPositions | null;
 };
 
 export type WorkerTileCallback = (error?: Error | null, result?: WorkerTileResult | null) => void;
@@ -78,38 +78,38 @@ export type WorkerDEMTileCallback = (err?: Error | null, result?: DEMData | null
  * @param layerIndex
  */
 export interface WorkerSource {
-  availableImages: Array<string>;
-  // Disabled due to https://github.com/facebook/flow/issues/5208
-  // constructor(actor: Actor, layerIndex: StyleLayerIndex): WorkerSource;
+    availableImages: Array<string>;
+    // Disabled due to https://github.com/facebook/flow/issues/5208
+    // constructor(actor: Actor, layerIndex: StyleLayerIndex): WorkerSource;
 
-  /**
+    /**
      * Loads a tile from the given params and parse it into buckets ready to send
      * back to the main thread for rendering.  Should call the callback with:
      * `{ buckets, featureIndex, collisionIndex, rawTileData}`.
      */
-  loadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
-  /**
+    loadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
+    /**
      * Re-parses a tile that has already been loaded.  Yields the same data as
      * {@link WorkerSource#loadTile}.
      */
-  reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
-  /**
+    reloadTile(params: WorkerTileParameters, callback: WorkerTileCallback): void;
+    /**
      * Aborts loading a tile that is in progress.
      */
-  abortTile(params: TileParameters, callback: WorkerTileCallback): void;
-  /**
+    abortTile(params: TileParameters, callback: WorkerTileCallback): void;
+    /**
      * Removes this tile from any local caches.
      */
-  removeTile(params: TileParameters, callback: WorkerTileCallback): void;
-  /**
+    removeTile(params: TileParameters, callback: WorkerTileCallback): void;
+    /**
      * Tells the WorkerSource to abort in-progress tasks and release resources.
      * The foreground Source is responsible for ensuring that 'removeSource' is
      * the last message sent to the WorkerSource.
      */
-  removeSource?: (
-    params: {
-      source: string;
-    },
-    callback: WorkerTileCallback
-  ) => void;
+    removeSource?: (
+        params: {
+            source: string;
+        },
+        callback: WorkerTileCallback
+    ) => void;
 }

package/src/source/worker_tile.ts

@@ -1,7 +1,7 @@
 import FeatureIndex from '../data/feature_index';
 
 import {performSymbolLayout} from '../symbol/symbol_layout';
-import {CollisionBoxArray} from '../data/array_types';
+import {CollisionBoxArray} from '../data/array_types.g';
 import DictionaryCoder from '../util/dictionary_coder';
 import SymbolBucket from '../data/bucket/symbol_bucket';
 import LineBucket from '../data/bucket/line_bucket';
@@ -130,9 +130,9 @@ class WorkerTile {
 
         let error: Error;
         let glyphMap: {
-          [_: string]: {
-            [_: number]: StyleGlyph;
-          };
+            [_: string]: {
+                [_: number]: StyleGlyph;
+            };
         };
         let iconMap: {[_: string]: StyleImage};
         let patternMap: {[_: string]: StyleImage};

package/src/style/evaluation_parameters.ts

@@ -5,9 +5,9 @@ import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
 import type {TransitionSpecification} from '../style-spec/types';
 
 export type CrossfadeParameters = {
-  fromScale: number;
-  toScale: number;
-  t: number;
+    fromScale: number;
+    toScale: number;
+    t: number;
 };
 
 class EvaluationParameters {

package/src/style/format_section_override.test.ts

@@ -1,6 +1,6 @@
 import {createExpression, StyleExpression, ZoomConstantExpression} from '../style-spec/expression';
 import EvaluationContext from '../style-spec/expression/evaluation_context';
-import properties from './style_layer/symbol_style_layer_properties';
+import properties from './style_layer/symbol_style_layer_properties.g';
 import {PossiblyEvaluatedPropertyValue} from './properties';
 import FormatSectionOverride from './format_section_override';
 import EvaluationParameters from './evaluation_parameters';

package/src/style/light.ts

@@ -24,9 +24,9 @@ import type {
 import type {LightSpecification} from '../style-spec/types';
 
 type LightPosition = {
-  x: number;
-  y: number;
-  z: number;
+    x: number;
+    y: number;
+    z: number;
 };
 
 class LightPositionProperty implements Property<[number, number, number], LightPosition> {
@@ -37,8 +37,8 @@ class LightPositionProperty implements Property<[number, number, number], LightP
     }
 
     possiblyEvaluate(
-      value: PropertyValue<[number, number, number], LightPosition>,
-      parameters: EvaluationParameters
+        value: PropertyValue<[number, number, number], LightPosition>,
+        parameters: EvaluationParameters
     ): LightPosition {
         return sphericalToCartesian(value.expression.evaluate(parameters));
     }
@@ -53,10 +53,10 @@ class LightPositionProperty implements Property<[number, number, number], LightP
 }
 
 type Props = {
-  'anchor': DataConstantProperty<'map' | 'viewport'>;
-  'position': LightPositionProperty;
-  'color': DataConstantProperty<Color>;
-  'intensity': DataConstantProperty<number>;
+    'anchor': DataConstantProperty<'map' | 'viewport'>;
+    'position': LightPositionProperty;
+    'color': DataConstantProperty<Color>;
+    'intensity': DataConstantProperty<number>;
 };
 
 type PropsPossiblyEvaluated = {
@@ -122,7 +122,7 @@ class Light extends Evented {
     }
 
     _validate(validate: Function, value: unknown, options?: {
-      validate?: boolean;
+        validate?: boolean;
     }) {
         if (options && options.validate === false) {
             return false;

package/src/style/load_glyph_range.test.ts

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import {RequestManager} from '../util/request_manager';
 import loadGlyphRange from './load_glyph_range';
-import {useFakeXMLHttpRequest} from 'sinon';
+import {fakeXhr} from 'nise';
 
 test('loadGlyphRange', done => {
     global.fetch = null;
@@ -14,7 +14,7 @@ test('loadGlyphRange', done => {
     const manager = new RequestManager(transform);
 
     let request;
-    useFakeXMLHttpRequest().onCreate = (req) => { request = req; };
+    fakeXhr.useFakeXMLHttpRequest().onCreate = (req) => { request = req; };
 
     loadGlyphRange('Arial Unicode MS', 0, 'https://localhost/fonts/v1/{fontstack}/{range}.pbf', manager, (err, result) => {
         expect(err).toBeFalsy();
@@ -26,8 +26,6 @@ test('loadGlyphRange', done => {
             const id = Number(key);
             const glyph = result[id];
 
-            if (!glyph) return done.fail(); // appease flow
-
             expect(glyph.id).toBe(Number(id));
             expect(glyph.metrics).toBeTruthy();
             expect(typeof glyph.metrics.width).toBe('number');
@@ -40,6 +38,6 @@ test('loadGlyphRange', done => {
 
     expect(request.url).toBe('https://localhost/fonts/v1/Arial Unicode MS/0-255.pbf');
     request.setStatus(200);
-    request.response = fs.readFileSync(path.join(__dirname, '../../test/fixtures/0-255.pbf'));
+    request.response = fs.readFileSync(path.join(__dirname, '../../test/unit/assets/0-255.pbf'));
     request.onload();
 });

package/src/style/load_glyph_range.ts

@@ -7,12 +7,12 @@ import type {RequestManager} from '../util/request_manager';
 import type {Callback} from '../types/callback';
 
 export default function loadGlyphRange(fontstack: string,
-                           range: number,
-                           urlTemplate: string,
-                           requestManager: RequestManager,
-                           callback: Callback<{
-                             [_: number]: StyleGlyph | null;
-                           }>) {
+    range: number,
+    urlTemplate: string,
+    requestManager: RequestManager,
+    callback: Callback<{
+        [_: number]: StyleGlyph | null;
+    }>) {
     const begin = range * 256;
     const end = begin + 255;
 

package/src/style/load_sprite.ts

@@ -9,12 +9,13 @@ import type {Callback} from '../types/callback';
 import type {Cancelable} from '../types/cancelable';
 
 export default function(
-  baseURL: string,
-  requestManager: RequestManager,
-  callback: Callback<{[_: string]: StyleImage}>
+    baseURL: string,
+    requestManager: RequestManager,
+    pixelRatio: number,
+    callback: Callback<{[_: string]: StyleImage}>
 ): Cancelable {
     let json: any, image, error;
-    const format = devicePixelRatio > 1 ? '@2x' : '';
+    const format = pixelRatio > 1 ? '@2x' : '';
 
     let jsonRequest = getJSON(requestManager.transformRequest(requestManager.normalizeSpriteURL(baseURL, format, '.json'), ResourceType.SpriteJSON), (err?: Error | null, data?: any | null) => {
         jsonRequest = null;

package/src/style/pauseable_placement.ts

@@ -13,7 +13,7 @@ class LayerPlacement {
     _currentTileIndex: number;
     _currentPartIndex: number;
     _seenCrossTileIDs: {
-      [k in string | number]: boolean;
+        [k in string | number]: boolean;
     };
     _bucketParts: Array<BucketPart>;