maplibre-gl 3.2.0 → 3.2.2

package/src/util/ajax.test.ts

@@ -7,6 +7,7 @@ import {
 } from './ajax';
 
 import {fakeServer, FakeServer} from 'nise';
+import {destroyFetchMock, FetchMock, RequestMock, setupFetchMock} from './test/mock_fetch';
 
 function readAsText(blob) {
     return new Promise((resolve, reject) => {
@@ -141,4 +142,36 @@ describe('ajax', () => {
         // edge case
         expect(sameOrigin('://foo')).toBe(true);
     });
+
+    describe('requests parameters', () => {
+        let fetch: FetchMock;
+
+        beforeEach(() => {
+            fetch = setupFetchMock();
+        });
+
+        afterEach(() => {
+            destroyFetchMock();
+        });
+
+        test('should be provided to fetch API in getArrayBuffer function', (done) => {
+            getArrayBuffer({url: 'http://example.com/test-params.json', cache: 'force-cache', headers: {'Authorization': 'Bearer 123'}}, () => {
+                expect(fetch).toHaveBeenCalledTimes(1);
+                expect(fetch).toHaveBeenCalledWith(expect.objectContaining({url: 'http://example.com/test-params.json', method: 'GET', cache: 'force-cache'}));
+                expect((fetch.mock.calls[0][0] as RequestMock).headers.get('Authorization')).toBe('Bearer 123');
+
+                done();
+            });
+        });
+
+        test('should be provided to fetch API in getJSON function', (done) => {
+            getJSON({url: 'http://example.com/test-params.json', cache: 'force-cache', headers: {'Authorization': 'Bearer 123'}}, () => {
+                expect(fetch).toHaveBeenCalledTimes(1);
+                expect(fetch).toHaveBeenCalledWith(expect.objectContaining({url: 'http://example.com/test-params.json', method: 'GET', cache: 'force-cache'}));
+                expect((fetch.mock.calls[0][0] as RequestMock).headers.get('Authorization')).toBe('Bearer 123');
+
+                done();
+            });
+        });
+    });
 });

package/src/util/ajax.ts

@@ -49,6 +49,10 @@ export type RequestParameters = {
      * If `true`, Resource Timing API information will be collected for these transformed requests and returned in a resourceTiming property of relevant data events.
      */
     collectResourceTiming?: boolean;
+    /**
+     * Parameters supported only by browser fetch API. Property of the Request interface contains the cache mode of the request. It controls how the request will interact with the browser's HTTP cache. (https://developer.mozilla.org/en-US/docs/Web/API/Request/cache)
+     */
+    cache?: RequestCache;
 };
 
 /**
@@ -123,6 +127,7 @@ function makeFetchRequest(requestParameters: RequestParameters, callback: Respon
         body: requestParameters.body,
         credentials: requestParameters.credentials,
         headers: requestParameters.headers,
+        cache: requestParameters.cache,
         referrer: getReferrer(),
         signal: controller.signal
     });

package/src/util/image.ts

@@ -82,6 +82,7 @@ function copyImage(srcImg: any, dstImg: any, srcPt: Point2D, dstPt: Point2D, siz
 }
 
 /**
+ * @internal
  * An image with alpha color value
  */
 export class AlphaImage {

package/src/util/image_request.ts

@@ -2,7 +2,7 @@ import type {Cancelable} from '../types/cancelable';
 import {RequestParameters, ExpiryData, makeRequest, sameOrigin, getProtocolAction} from './ajax';
 import type {Callback} from '../types/callback';
 
-import {arrayBufferToImageBitmap, arrayBufferToImage, extend, isWorker} from './util';
+import {arrayBufferToImageBitmap, arrayBufferToImage, extend, isWorker, isImageBitmap} from './util';
 import {webpSupported} from './webp_supported';
 import {config} from './config';
 
@@ -202,7 +202,7 @@ export namespace ImageRequest {
         expires?: string | null): void => {
         if (err) {
             callback(err);
-        } else if (data instanceof HTMLImageElement || data instanceof ImageBitmap) {
+        } else if (data instanceof HTMLImageElement || isImageBitmap(data)) {
             // User using addProtocol can directly return HTMLImageElement/ImageBitmap type
             // If HtmlImageElement is used to get image then response type will be HTMLImageElement
             callback(null, data);

package/src/util/performance.ts

@@ -75,9 +75,8 @@ export const PerformanceUtils = {
 };
 
 /**
+ * @internal
  * Safe wrapper for the performance resource timing API in web workers with graceful degradation
- *
- * @hidden
  */
 export class RequestPerformance {
     _marks: {

package/src/util/struct_array.ts

@@ -3,6 +3,7 @@
 import type {Transferable} from '../types/transferable';
 
 /**
+ * @internal
  * A view type size
  */
 const viewTypes = {
@@ -16,11 +17,12 @@ const viewTypes = {
 };
 
 /**
+ * @internal
  * A view type size
  */
 export type ViewType = keyof typeof viewTypes;
 
-/** */
+/** @internal */
 class Struct {
     _pos1: number;
     _pos2: number;
@@ -48,6 +50,7 @@ const DEFAULT_CAPACITY = 128;
 const RESIZE_MULTIPLIER = 5;
 
 /**
+ * @internal
  * A struct array memeber
  */
 export type StructArrayMember = {
@@ -72,6 +75,7 @@ export type SerializedStructArray = {
 };
 
 /**
+ * @internal
  * `StructArray` provides an abstraction over `ArrayBuffer` and `TypedArray`
  * making it behave like an array of typed structs.
  *

package/src/util/test/mock_fetch.ts

@@ -0,0 +1,51 @@
+export class RequestMock implements Partial<Request> {
+    public readonly cache: RequestCache;
+    public readonly headers: Headers = new Headers();
+    public readonly method?: string;
+    public readonly url?: string;
+
+    public get signal(): AbortSignal {
+        return null;
+    }
+
+    constructor(input: RequestInfo | URL, init?: RequestInit) {
+        this.cache = typeof input === 'object' && 'cache' in input ? input.cache : init.cache;
+        this.method = typeof input === 'object' && 'method' in input ? input.method : init.method;
+        this.url = typeof input === 'object' && 'url' in input ? input.url : input.toString();
+        this.headers = typeof input === 'object' && 'headers' in input ? new Headers(input.headers) : new Headers(init.headers || {});
+    }
+}
+
+class AbortControllerMock {
+    public signal: AbortSignal;
+
+    public abort(): void {}
+}
+
+export type FetchMock = jest.Mock<Promise<Response>, [input: RequestInfo | URL, init?: RequestInit], any>;
+
+let _AbortController: typeof AbortController;
+let _Request: typeof Request;
+let _fetch: typeof fetch;
+
+export function destroyFetchMock(): void {
+    global.AbortController = _AbortController ?? global.AbortController;
+    global.Request = _Request ?? global.Request;
+    global.fetch = _fetch ?? global.fetch;
+}
+
+export function setupFetchMock(): FetchMock {
+    _AbortController = _AbortController ?? global.AbortController;
+    _Request = _Request ?? global.Request;
+    _fetch = _fetch ?? global.fetch;
+
+    const fetchMock = jest.fn(async (_input: RequestInfo | URL, _init?: RequestInit): Promise<Response> => {
+        return <Response>{};
+    });
+
+    global.AbortController = AbortControllerMock;
+    global.Request = RequestMock as unknown as typeof Request;
+    global.fetch = fetchMock;
+
+    return fetchMock;
+}