maplibre-gl 2.0.4 → 2.1.2

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

@@ -99,3 +99,17 @@ export function getMockDispatcher() {
 
     return mockDispatcher;
 }
+
+export function stubAjaxGetImage(createImageBitmap) {
+    global.createImageBitmap = createImageBitmap;
+
+    global.URL.revokeObjectURL = () => {};
+    global.URL.createObjectURL = (_) => { return null; };
+
+    // eslint-disable-next-line accessor-pairs
+    Object.defineProperty(global.Image.prototype, 'src', {
+        set(_) {
+            this.onload();
+        }
+    });
+}

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

package/src/util/web_worker.ts

@@ -1,13 +1,8 @@
-// When Rollup builds the main bundle this file is replaced with ./build/web_worker_replacement.js
-// See package.json 'browser' field and rollup documentation.
-// This file is intended for use in the GL-JS test suite when they run on node since node doesn't support workers.
-// It implements a MessageBus main thread interface
-
-import MaplibreWorker from '../source/worker';
+import maplibregl from '../index';
 
 import type {WorkerSource} from '../source/worker_source';
 
-type MessageListener = (
+export type MessageListener = (
     a: {
         data: any;
         target: any;
@@ -15,7 +10,6 @@ type MessageListener = (
 ) => unknown;
 
 // The main thread interface. Provided by Worker in a browser environment,
-// and MessageBus below in a node environment.
 export interface WorkerInterface {
     addEventListener(type: 'message', listener: MessageListener): void;
     removeEventListener(type: 'message', listener: MessageListener): void;
@@ -34,64 +28,6 @@ export interface WorkerGlobalScopeInterface {
     registerRTLTextPlugin: (_: any) => void;
 }
 
-class MessageBus implements WorkerInterface, WorkerGlobalScopeInterface {
-    addListeners: Array<MessageListener>;
-    postListeners: Array<MessageListener>;
-    target: MessageBus;
-    registerWorkerSource: any;
-    registerRTLTextPlugin: any;
-
-    constructor(addListeners: Array<MessageListener>, postListeners: Array<MessageListener>) {
-        this.addListeners = addListeners;
-        this.postListeners = postListeners;
-    }
-
-    addEventListener(event: 'message', callback: MessageListener) {
-        if (event === 'message') {
-            this.addListeners.push(callback);
-        }
-    }
-
-    removeEventListener(event: 'message', callback: MessageListener) {
-        const i = this.addListeners.indexOf(callback);
-        if (i >= 0) {
-            this.addListeners.splice(i, 1);
-        }
-    }
-
-    postMessage(data: any) {
-        setTimeout(() => {
-            try {
-                for (const listener of this.postListeners) {
-                    listener({data, target: this.target});
-                }
-            } catch (e) {
-                console.error(e);
-            }
-        }, 0);
-    }
-
-    terminate() {
-        this.addListeners.splice(0, this.addListeners.length);
-        this.postListeners.splice(0, this.postListeners.length);
-    }
-
-    importScripts() { }
-}
-
-export default function workerFactory(): WorkerInterface {
-    const parentListeners = [],
-        workerListeners = [],
-        parentBus = new MessageBus(workerListeners, parentListeners),
-        workerBus = new MessageBus(parentListeners, workerListeners);
-
-    parentBus.target = workerBus;
-    workerBus.target = parentBus;
-
-    new workerFactory.Worker(workerBus);
-
-    return parentBus;
+export default function workerFactory() {
+    return new Worker(maplibregl.workerUrl);
 }
-
-// expose to allow stubbing in unit tests
-workerFactory.Worker = MaplibreWorker;

package/src/util/web_worker_transfer.test.ts

@@ -5,11 +5,13 @@ describe('web worker transfer', () => {
         class SerializableMock {
             n;
             buffer;
+            blob;
             _cached;
 
             constructor(n) {
                 this.n = n;
                 this.buffer = new ArrayBuffer(100);
+                this.blob = new Blob();
                 this.squared();
             }
 
@@ -33,6 +35,7 @@ describe('web worker transfer', () => {
         expect(deserialized.constructor === SerializableMock).toBeTruthy();
         expect(deserialized.n === 10).toBeTruthy();
         expect(deserialized.buffer === serializableMock.buffer).toBeTruthy();
+        expect(deserialized.blob === serializableMock.blob).toBeTruthy();
         expect(transferables[0] === serializableMock.buffer).toBeTruthy();
         expect(deserialized._cached === undefined).toBeTruthy();
         expect(deserialized.squared() === 100).toBeTruthy();