maplibre-gl 2.1.0 → 2.1.4

package/src/util/actor.test.ts

@@ -1,15 +1,42 @@
 import Actor from './actor';
 import workerFactory from './web_worker';
+import {MessageBus} from '../../test/unit/lib/web_worker_mock';
+
+const originalWorker = global.Worker;
+
+function setTestWorker(MockWorker: { new(...args: any): any}) {
+    (global as any).Worker = function Worker(_: string) {
+        const parentListeners = [];
+        const workerListeners = [];
+        const parentBus = new MessageBus(workerListeners, parentListeners);
+        const workerBus = new MessageBus(parentListeners, workerListeners);
+
+        parentBus.target = workerBus;
+        workerBus.target = parentBus;
+
+        new MockWorker(workerBus);
+
+        return parentBus;
+    };
+}
 
 describe('Actor', () => {
+    afterAll(() => {
+        global.Worker = originalWorker;
+    });
+
     test('forwards responses to correct callback', done => {
-        jest.spyOn(workerFactory, 'Worker').mockImplementation(function Worker(self) {
-            this.self = self;
-            this.actor = new Actor(self, this);
-            this.test = function (mapId, params, callback) {
+        setTestWorker(class MockWorker {
+            self: any;
+            actor: Actor;
+            constructor(self) {
+                this.self = self;
+                this.actor = new Actor(self, this);
+            }
+            test(mapId, params, callback) {
                 setTimeout(callback, 0, null, params);
-            };
-        } as any);
+            }
+        });
 
         const worker = workerFactory();
 
@@ -38,10 +65,14 @@ describe('Actor', () => {
     test('targets worker-initiated messages to correct map instance', done => {
         let workerActor;
 
-        jest.spyOn(workerFactory, 'Worker').mockImplementation(function Worker(self) {
-            this.self = self;
-            this.actor = workerActor = new Actor(self, this);
-        } as any);
+        setTestWorker(class MockWorker {
+            self: any;
+            actor: Actor;
+            constructor(self) {
+                this.self = self;
+                this.actor = workerActor = new Actor(self, this);
+            }
+        });
 
         const worker = workerFactory();
 

package/src/util/actor.ts

@@ -21,15 +21,15 @@ class Actor {
     parent: any;
     mapId: number;
     callbacks: {
-      number: any;
+        number: any;
     };
     name: string;
     tasks: {
-      number: any;
+        number: any;
     };
     taskQueue: Array<number>;
     cancelCallbacks: {
-      number: Cancelable;
+        number: Cancelable;
     };
     invoker: ThrottledInvoker;
     globalScope: any;
@@ -57,11 +57,11 @@ class Actor {
      * @private
      */
     send(
-      type: string,
-      data: unknown,
-      callback?: Function | null,
-      targetMapId?: string | null,
-      mustQueue: boolean = false
+        type: string,
+        data: unknown,
+        callback?: Function | null,
+        targetMapId?: string | null,
+        mustQueue: boolean = false
     ): Cancelable {
         // We're using a string ID instead of numbers because they are being used as object keys
         // anyway, and thus stringified implicitly. We use random IDs because an actor may receive

package/src/util/ajax.test.ts

@@ -3,15 +3,25 @@ import {
     getJSON,
     postData,
     getImage,
-    resetImageRequestQueue
+    resetImageRequestQueue,
+    AJAXError
 } from './ajax';
 import config from './config';
 import webpSupported from './webp_supported';
-import {fakeServer, SinonFakeServer} from 'sinon';
+import {fakeServer, FakeServer} from 'nise';
 import {stubAjaxGetImage} from './test/util';
 
+function readAsText(blob) {
+    return new Promise((resolve, reject) => {
+        const fileReader = new FileReader();
+        fileReader.onload = () => resolve(fileReader.result);
+        fileReader.onerror = () => reject(fileReader.error);
+        fileReader.readAsText(blob);
+    });
+}
+
 describe('ajax', () => {
-    let server: SinonFakeServer;
+    let server: FakeServer;
     beforeEach(() => {
         global.fetch = null;
         server = fakeServer.create();
@@ -22,10 +32,15 @@ describe('ajax', () => {
 
     test('getArrayBuffer, 404', done => {
         server.respondWith(request => {
-            request.respond(404, undefined, undefined);
+            request.respond(404, undefined, '404 Not Found');
         });
-        getArrayBuffer({url:''}, (error) => {
-            expect((error as any).status).toBe(404);
+        getArrayBuffer({url:'http://example.com/test.bin'}, async (error) => {
+            const ajaxError = error as AJAXError;
+            const body = await readAsText(ajaxError.body);
+            expect(ajaxError.status).toBe(404);
+            expect(ajaxError.statusText).toBe('Not Found');
+            expect(ajaxError.url).toBe('http://example.com/test.bin');
+            expect(body).toBe('404 Not Found');
             done();
         });
         server.respond();
@@ -56,22 +71,15 @@ describe('ajax', () => {
 
     test('getJSON, 404', done => {
         server.respondWith(request => {
-            request.respond(404, undefined, undefined);
-        });
-        getJSON({url:''}, (error) => {
-            expect((error as any).status).toBe(404);
-            done();
+            request.respond(404, undefined, '404 Not Found');
         });
-        server.respond();
-    });
-
-    test('getJSON, 401: non-Mapbox domain', done => {
-        server.respondWith(request => {
-            request.respond(401, undefined, undefined);
-        });
-        getJSON({url:''}, (error) => {
-            expect((error as any).status).toBe(401);
-            expect(error.message).toBe('Unauthorized');
+        getJSON({url:'http://example.com/test.json'}, async (error) => {
+            const ajaxError = error as AJAXError;
+            const body = await readAsText(ajaxError.body);
+            expect(ajaxError.status).toBe(404);
+            expect(ajaxError.statusText).toBe('Not Found');
+            expect(ajaxError.url).toBe('http://example.com/test.json');
+            expect(body).toBe('404 Not Found');
             done();
         });
         server.respond();

package/src/util/ajax.ts

@@ -64,37 +64,57 @@ if (typeof Object.freeze == 'function') {
  *
  */
 export type RequestParameters = {
-  url: string;
-  headers?: any;
-  method?: 'GET' | 'POST' | 'PUT';
-  body?: string;
-  type?: 'string' | 'json' | 'arrayBuffer';
-  credentials?: 'same-origin' | 'include';
-  collectResourceTiming?: boolean;
+    url: string;
+    headers?: any;
+    method?: 'GET' | 'POST' | 'PUT';
+    body?: string;
+    type?: 'string' | 'json' | 'arrayBuffer';
+    credentials?: 'same-origin' | 'include';
+    collectResourceTiming?: boolean;
 };
 
 export type ResponseCallback<T> = (
-  error?: Error | null,
-  data?: T | null,
-  cacheControl?: string | null,
-  expires?: string | null
+    error?: Error | null,
+    data?: T | null,
+    cacheControl?: string | null,
+    expires?: string | null
 ) => void;
 
-class AJAXError extends Error {
+/**
+ * An error thrown when a HTTP request results in an error response.
+ * @extends Error
+ * @param {number} status The response's HTTP status code.
+ * @param {string} statusText The response's HTTP status text.
+ * @param {string} url The request's URL.
+ * @param {Blob} body The response's body.
+ */
+export class AJAXError extends Error {
+    /**
+     * The response's HTTP status code.
+     */
     status: number;
+
+    /**
+     * The response's HTTP status text.
+     */
+    statusText: string;
+
+    /**
+     * The request's URL.
+     */
     url: string;
-    constructor(message: string, status: number, url: string) {
-        super(message);
-        this.status = status;
-        this.url = url;
 
-        // work around for https://github.com/Rich-Harris/buble/issues/40
-        this.name = this.constructor.name;
-        this.message = message;
-    }
+    /**
+     * The response's body.
+     */
+    body: Blob;
 
-    toString() {
-        return `${this.name}: ${this.message} (${this.status}): ${this.url}`;
+    constructor(status: number, statusText: string, url: string, body: Blob) {
+        super(`AJAXError: ${statusText} (${status}): ${url}`);
+        this.status = status;
+        this.statusText = statusText;
+        this.url = url;
+        this.body = body;
     }
 }
 
@@ -159,7 +179,7 @@ function makeFetchRequest(requestParameters: RequestParameters, callback: Respon
                 return finishRequest(response, cacheableResponse, requestTime);
 
             } else {
-                return callback(new AJAXError(response.statusText, response.status, requestParameters.url));
+                return response.blob().then(body => callback(new AJAXError(response.status, response.statusText, requestParameters.url, body)));
             }
         }).catch(error => {
             if (error.code === 20) {
@@ -173,8 +193,8 @@ function makeFetchRequest(requestParameters: RequestParameters, callback: Respon
     const finishRequest = (response, cacheableResponse?, requestTime?) => {
         (
             requestParameters.type === 'arrayBuffer' ? response.arrayBuffer() :
-            requestParameters.type === 'json' ? response.json() :
-            response.text()
+                requestParameters.type === 'json' ? response.json() :
+                    response.text()
         ).then(result => {
             if (aborted) return;
             if (cacheableResponse && requestTime) {
@@ -235,7 +255,8 @@ function makeXMLHttpRequest(requestParameters: RequestParameters, callback: Resp
             }
             callback(null, data, xhr.getResponseHeader('Cache-Control'), xhr.getResponseHeader('Expires'));
         } else {
-            callback(new AJAXError(xhr.statusText, xhr.status, requestParameters.url));
+            const body = new Blob([xhr.response], {type: xhr.getResponseHeader('Content-Type')});
+            callback(new AJAXError(xhr.status, xhr.statusText, requestParameters.url, body));
         }
     };
     xhr.send(requestParameters.body);
@@ -277,8 +298,8 @@ export const getJSON = function(requestParameters: RequestParameters, callback:
 };
 
 export const getArrayBuffer = function(
-  requestParameters: RequestParameters,
-  callback: ResponseCallback<ArrayBuffer>
+    requestParameters: RequestParameters,
+    callback: ResponseCallback<ArrayBuffer>
 ): Cancelable {
     return makeRequest(extend(requestParameters, {type: 'arrayBuffer'}), callback);
 };
@@ -339,8 +360,8 @@ export const resetImageRequestQueue = () => {
 resetImageRequestQueue();
 
 export const getImage = function(
-  requestParameters: RequestParameters,
-  callback: Callback<HTMLImageElement | ImageBitmap>
+    requestParameters: RequestParameters,
+    callback: Callback<HTMLImageElement | ImageBitmap>
 ): Cancelable {
     if (webpSupported.supported) {
         if (!requestParameters.headers) {

package/src/util/browser.ts

@@ -1,6 +1,6 @@
 import type {Cancelable} from '../types/cancelable';
 
-const now = performance && performance.now ?
+const now = typeof performance !== 'undefined' && performance && performance.now ?
     performance.now.bind(performance) :
     Date.now.bind(Date);
 

package/src/util/classify_rings.test.ts

@@ -6,7 +6,7 @@ import classifyRings from './classify_rings';
 import Point from '@mapbox/point-geometry';
 
 // Load a fill feature from fixture tile.
-const vt = new VectorTile(new Protobuf(fs.readFileSync(path.resolve(__dirname, '../../test/fixtures/mbsv5-6-18-23.vector.pbf'))));
+const vt = new VectorTile(new Protobuf(fs.readFileSync(path.resolve(__dirname, '../../test/unit/assets/mbsv5-6-18-23.vector.pbf'))));
 const feature = vt.layers.water.feature(0);
 
 describe('classifyRings', () => {

package/src/util/color_ramp.ts

@@ -5,11 +5,11 @@ import assert from 'assert';
 import type {StylePropertyExpression} from '../style-spec/expression/index';
 
 export type ColorRampParams = {
-  expression: StylePropertyExpression;
-  evaluationKey: string;
-  resolution?: number;
-  image?: RGBAImage;
-  clips?: Array<any>;
+    expression: StylePropertyExpression;
+    evaluationKey: string;
+    resolution?: number;
+    image?: RGBAImage;
+    clips?: Array<any>;
 };
 
 /**

package/src/util/config.ts

@@ -1,6 +1,6 @@
 type Config = {
-  MAX_PARALLEL_IMAGE_REQUESTS: number;
-  REGISTERED_PROTOCOLS: {[x: string]: any};
+    MAX_PARALLEL_IMAGE_REQUESTS: number;
+    REGISTERED_PROTOCOLS: {[x: string]: any};
 };
 
 const config: Config = {

package/src/util/dispatcher.ts

@@ -18,7 +18,7 @@ class Dispatcher {
 
     // exposed to allow stubbing in unit tests
     static Actor: {
-      new (...args: any): Actor;
+        new (...args: any): Actor;
     };
 
     constructor(workerPool: WorkerPool, parent: any) {

package/src/util/dom.ts

@@ -53,7 +53,7 @@ export default class DOM {
     public static addEventListener(target: any, type: any, callback: any, options: {
         passive?: boolean;
         capture?: boolean;
-      } = {}) {
+    } = {}) {
         if ('passive' in options) {
             target.addEventListener(type, callback, options);
         } else {
@@ -64,7 +64,7 @@ export default class DOM {
     public static removeEventListener(target: any, type: any, callback: any, options: {
         passive?: boolean;
         capture?: boolean;
-      } = {}) {
+    } = {}) {
         if ('passive' in options) {
             target.removeEventListener(type, callback, options);
         } else {

package/src/util/evented.ts

@@ -31,7 +31,7 @@ export class Event {
 }
 
 interface ErrorLike {
-  message: string;
+    message: string;
 }
 
 export class ErrorEvent extends Event {

package/src/util/find_pole_of_inaccessibility.ts

@@ -14,9 +14,9 @@ import {distToSegmentSquared} from './intersection_tests';
  * @private
  */
 export default function(
-  polygonRings: Array<Array<Point>>,
-  precision: number = 1,
-  debug: boolean = false
+    polygonRings: Array<Array<Point>>,
+    precision: number = 1,
+    debug: boolean = false
 ): Point {
     // find the bounding box of the outer ring
     let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;

package/src/util/image.ts

@@ -3,13 +3,13 @@ import assert from 'assert';
 import {register} from './web_worker_transfer';
 
 export type Size = {
-  width: number;
-  height: number;
+    width: number;
+    height: number;
 };
 
 type Point2D = {
-  x: number;
-  y: number;
+    x: number;
+    y: number;
 };
 
 function createImage(image: any, {
@@ -21,7 +21,7 @@ function createImage(image: any, {
     } else if (data instanceof Uint8ClampedArray) {
         data = new Uint8Array(data.buffer);
     } else if (data.length !== width * height * channels) {
-        throw new RangeError('mismatched image size');
+        throw new RangeError(`mismatched image size. expected: ${data.length} but got: ${width * height * channels}`);
     }
     image.width = width;
     image.height = height;

package/src/util/performance.ts

@@ -1,10 +1,10 @@
 import type {RequestParameters} from '../util/ajax';
 
 export type PerformanceMetrics = {
-  loadTime: number;
-  fullLoadTime: number;
-  fps: number;
-  percentDroppedFrames: number;
+    loadTime: number;
+    fullLoadTime: number;
+    fps: number;
+    percentDroppedFrames: number;
 };
 
 export enum PerformanceMarkers {
@@ -76,9 +76,9 @@ export const PerformanceUtils = {
  */
 export class RequestPerformance {
     _marks: {
-      start: string;
-      end: string;
-      measure: string;
+        start: string;
+        end: string;
+        measure: string;
     };
 
     constructor (request: RequestParameters) {

package/src/util/request_manager.ts

@@ -6,10 +6,10 @@ type ResourceTypeEnum = keyof IResourceType;
 export type RequestTransformFunction = (url: string, resourceType?: ResourceTypeEnum) => RequestParameters;
 
 type UrlObject = {
-  protocol: string;
-  authority: string;
-  path: string;
-  params: Array<string>;
+    protocol: string;
+    authority: string;
+    path: string;
+    params: Array<string>;
 };
 
 export class RequestManager {

package/src/util/resolve_tokens.ts

@@ -9,10 +9,10 @@ export default resolveTokens;
  * @private
  */
 function resolveTokens(
-  properties: {
-    readonly [x: string]: unknown;
-  },
-  text: string
+    properties: {
+        readonly [x: string]: unknown;
+    },
+    text: string
 ): string {
     return text.replace(/{([^{}]+)}/g, (match, key: string) => {
         return key in properties ? String(properties[key]) : '';

package/src/util/struct_array.test.ts

@@ -1,4 +1,4 @@
-import {StructArrayLayout3i6, FeatureIndexArray} from '../data/array_types';
+import {StructArrayLayout3i6, FeatureIndexArray} from '../data/array_types.g';
 
 describe('StructArray', () => {
     class TestArray extends StructArrayLayout3i6 {}

package/src/util/struct_array.ts

@@ -47,21 +47,21 @@ const DEFAULT_CAPACITY = 128;
 const RESIZE_MULTIPLIER = 5;
 
 export type StructArrayMember = {
-  name: string;
-  type: ViewType;
-  components: number;
-  offset: number;
+    name: string;
+    type: ViewType;
+    components: number;
+    offset: number;
 };
 
 export type StructArrayLayout = {
-  members: Array<StructArrayMember>;
-  size: number;
-  alignment: number;
+    members: Array<StructArrayMember>;
+    size: number;
+    alignment: number;
 };
 
 export type SerializedStructArray = {
-  length: number;
-  arrayBuffer: ArrayBuffer;
+    length: number;
+    arrayBuffer: ArrayBuffer;
 };
 
 /**
@@ -198,12 +198,12 @@ abstract class StructArray {
  * @private
  */
 function createLayout(
-  members: Array<{
-    name: string;
-    type: ViewType;
-    readonly components?: number;
-  }>,
-  alignment: number = 1
+    members: Array<{
+        name: string;
+        type: ViewType;
+        readonly components?: number;
+    }>,
+    alignment: number = 1
 ): StructArrayLayout {
 
     let offset = 0;

package/src/util/task_queue.ts

@@ -3,9 +3,9 @@ import assert from 'assert';
 export type TaskID = number; // can't mark opaque due to https://github.com/flowtype/flow-remove-types/pull/61
 
 type Task = {
-  callback: (timeStamp: number) => void;
-  id: TaskID;
-  cancelled: boolean;
+    callback: (timeStamp: number) => void;
+    id: TaskID;
+    cancelled: boolean;
 };
 
 class TaskQueue {

package/src/util/tile_request_cache.ts

@@ -9,9 +9,9 @@ let cacheCheckThreshold = 50;
 const MIN_TIME_UNTIL_EXPIRY = 1000 * 60 * 7; // 7 minutes. Skip caching tiles with a short enough max age.
 
 export type ResponseOptions = {
-  status: number;
-  statusText: string;
-  headers: Headers;
+    status: number;
+    statusText: string;
+    headers: Headers;
 };
 
 // We're using a global shared cache object. Normally, requesting ad-hoc Cache objects is fine, but

package/src/util/transferable_grid_index.ts

@@ -148,10 +148,10 @@ class TransferableGridIndex {
             for (let y = cy1; y <= cy2; y++) {
                 const cellIndex = this.d * y + x;
                 if (intersectionTest && !intersectionTest(
-                            this._convertFromCellCoord(x),
-                            this._convertFromCellCoord(y),
-                            this._convertFromCellCoord(x + 1),
-                            this._convertFromCellCoord(y + 1))) continue;
+                    this._convertFromCellCoord(x),
+                    this._convertFromCellCoord(y),
+                    this._convertFromCellCoord(x + 1),
+                    this._convertFromCellCoord(y + 1))) continue;
                 if (fn.call(this, x1, y1, x2, y2, cellIndex, arg1, arg2, intersectionTest)) return;
             }
         }

package/src/util/util.ts

@@ -88,9 +88,9 @@ export function wrap(n: number, min: number, max: number): number {
  * @private
  */
 export function asyncAll<Item, Result>(
-  array: Array<Item>,
-  fn: (item: Item, fnCallback: Callback<Result>) => void,
-  callback: Callback<Array<Result>>
+    array: Array<Item>,
+    fn: (item: Item, fnCallback: Callback<Result>) => void,
+    callback: Callback<Array<Result>>
 ) {
     if (!array.length) { return callback(null, []); }
     let remaining = array.length;
@@ -113,8 +113,8 @@ export function asyncAll<Item, Result>(
  * @private
  */
 export function keysDifference<S, T>(
-  obj: {[key: string]: S},
-  other: {[key: string]: T}
+    obj: {[key: string]: S},
+    other: {[key: string]: T}
 ): Array<string> {
     const difference = [];
     for (const i in obj) {
@@ -365,9 +365,9 @@ export function isClosedPolygon(points: Array<Point>): boolean {
  */
 
 export function sphericalToCartesian([r, azimuthal, polar]: [number, number, number]): {
-  x: number;
-  y: number;
-  z: number;
+    x: number;
+    y: number;
+    z: number;
 } {
     // We abstract "north"/"up" (compass-wise) to be 0° when really this is 90° (π/2):
     // correct for that here