maplibre-gl 3.5.1 → 3.5.2

package/src/util/actor.ts

@@ -1,9 +1,57 @@
-import {isWorker, isSafari} from './util';
-import {serialize, deserialize} from './web_worker_transfer';
+import {isWorker} from './util';
+import {serialize, deserialize, Serialized} from './web_worker_transfer';
 import {ThrottledInvoker} from './throttled_invoker';
 
 import type {Transferable} from '../types/transferable';
 import type {Cancelable} from '../types/cancelable';
+import type {WorkerSource} from '../source/worker_source';
+import type {OverscaledTileID} from '../source/tile_id';
+import type {Callback} from '../types/callback';
+import type {StyleGlyph} from '../style/style_glyph';
+
+export interface ActorTarget {
+    addEventListener: typeof window.addEventListener;
+    removeEventListener: typeof window.removeEventListener;
+    postMessage: typeof window.postMessage;
+    terminate?: () => void;
+}
+
+export interface WorkerSourceProvider {
+    getWorkerSource(mapId: string | number, sourceType: string, sourceName: string): WorkerSource;
+}
+
+export interface GlyphsProvider {
+    getGlyphs(mapId: string, params: {
+        stacks: {[_: string]: Array<number>};
+        source: string;
+        tileID: OverscaledTileID;
+        type: string;
+    },
+        callback: Callback<{[_: string]: {[_: number]: StyleGlyph}}>
+    );
+}
+
+export type MessageType = '<response>' | '<cancel>' |
+'geojson.getClusterExpansionZoom' | 'geojson.getClusterChildren' | 'geojson.getClusterLeaves' | 'geojson.loadData' |
+'removeSource' | 'loadWorkerSource' | 'loadDEMTile' | 'removeDEMTile' |
+'removeTile' | 'reloadTile' | 'abortTile' | 'loadTile' | 'getTile' |
+'getGlyphs' | 'getImages' | 'setImages' |
+'syncRTLPluginState' | 'setReferrer' | 'setLayers' | 'updateLayers';
+
+export type MessageData = {
+    id: string;
+    type: MessageType;
+    data?: Serialized;
+    targetMapId?: string | number | null;
+    mustQueue?: boolean;
+    error?: Serialized | null;
+    hasCallback?: boolean;
+    sourceMapId: string | number | null;
+}
+
+export type Message = {
+    data: MessageData;
+}
 
 /**
  * An implementation of the [Actor design pattern](http://en.wikipedia.org/wiki/Actor_model)
@@ -12,36 +60,30 @@ import type {Cancelable} from '../types/cancelable';
  * owned by the styles
  */
 export class Actor {
-    target: any;
-    parent: any;
-    mapId: string | null;
-    callbacks: {
-        number: any;
-    };
+    target: ActorTarget;
+    parent: WorkerSourceProvider | GlyphsProvider;
+    mapId: string | number | null;
+    callbacks: { [x: number]: Function};
     name: string;
-    tasks: {
-        number: any;
-    };
-    taskQueue: Array<number>;
-    cancelCallbacks: {
-        number: Cancelable;
-    };
+    tasks: { [x: number]: MessageData };
+    taskQueue: Array<string>;
+    cancelCallbacks: { [x: number]: () => void };
     invoker: ThrottledInvoker;
-    globalScope: any;
+    globalScope: ActorTarget;
 
     /**
      * @param target - The target
      * @param parent - The parent
      * @param mapId - A unique identifier for the Map instance using this Actor.
      */
-    constructor(target: any, parent: any, mapId?: string) {
+    constructor(target: ActorTarget, parent: WorkerSourceProvider | GlyphsProvider, mapId?: string | number) {
         this.target = target;
         this.parent = parent;
         this.mapId = mapId;
-        this.callbacks = {} as { number: any };
-        this.tasks = {} as { number: any };
+        this.callbacks = {};
+        this.tasks = {};
         this.taskQueue = [];
-        this.cancelCallbacks = {} as { number: Cancelable };
+        this.cancelCallbacks = {};
         this.invoker = new ThrottledInvoker(this.process);
         this.target.addEventListener('message', this.receive, false);
         this.globalScope = isWorker() ? target : window;
@@ -55,7 +97,7 @@ export class Actor {
      * @param targetMapId - A particular mapId to which to send this message.
      */
     send(
-        type: string,
+        type: MessageType,
         data: unknown,
         callback?: Function | null,
         targetMapId?: string | null,
@@ -69,8 +111,8 @@ export class Actor {
         if (callback) {
             this.callbacks[id] = callback;
         }
-        const buffers: Array<Transferable> = isSafari(this.globalScope) ? undefined : [];
-        this.target.postMessage({
+        const buffers: Array<Transferable> = [];
+        const message: MessageData = {
             id,
             type,
             hasCallback: !!callback,
@@ -78,31 +120,27 @@ export class Actor {
             mustQueue,
             sourceMapId: this.mapId,
             data: serialize(data, buffers)
-        }, buffers);
+        };
+
+        this.target.postMessage(message, {transfer: buffers});
         return {
             cancel: () => {
                 if (callback) {
                     // Set the callback to null so that it never fires after the request is aborted.
                     delete this.callbacks[id];
                 }
-                this.target.postMessage({
+                const cancelMessage: MessageData = {
                     id,
                     type: '<cancel>',
                     targetMapId,
                     sourceMapId: this.mapId
-                });
+                };
+                this.target.postMessage(cancelMessage);
             }
         };
     }
 
-    receive = (message: {
-        data: {
-            id: number;
-            type: string;
-            data: unknown;
-            targetMapId?: string | null;
-            mustQueue: boolean;
-        };}) => {
+    receive = (message: Message) => {
         const data = message.data;
         const id = data.id;
 
@@ -164,7 +202,7 @@ export class Actor {
         this.processTask(id, task);
     };
 
-    processTask(id: number, task: any) {
+    processTask(id: string, task: MessageData) {
         if (task.type === '<response>') {
             // The done() function in the counterpart has been called, and we are now
             // firing the callback in the originating actor, if there is one.
@@ -180,30 +218,31 @@ export class Actor {
             }
         } else {
             let completed = false;
-            const buffers: Array<Transferable> = isSafari(this.globalScope) ? undefined : [];
+            const buffers: Array<Transferable> = [];
             const done = task.hasCallback ? (err: Error, data?: any) => {
                 completed = true;
                 delete this.cancelCallbacks[id];
-                this.target.postMessage({
+                const responseMessage: MessageData = {
                     id,
                     type: '<response>',
                     sourceMapId: this.mapId,
                     error: err ? serialize(err) : null,
                     data: serialize(data, buffers)
-                }, buffers);
+                };
+                this.target.postMessage(responseMessage, {transfer: buffers});
             } : (_) => {
                 completed = true;
             };
 
-            let callback = null;
-            const params = (deserialize(task.data) as any);
+            let callback: Cancelable = null;
+            const params = deserialize(task.data);
             if (this.parent[task.type]) {
                 // task.type == 'loadTile', 'removeTile', etc.
                 callback = this.parent[task.type](task.sourceMapId, params, done);
-            } else if (this.parent.getWorkerSource) {
+            } else if ('getWorkerSource' in this.parent) {
                 // task.type == sourcetype.method
                 const keys = task.type.split('.');
-                const scope = (this.parent as any).getWorkerSource(task.sourceMapId, keys[0], params.source);
+                const scope = this.parent.getWorkerSource(task.sourceMapId, keys[0], (params as any).source);
                 callback = scope[keys[1]](params, done);
             } else {
                 // No function was found.

package/src/util/dispatcher.test.ts

@@ -1,3 +1,4 @@
+import {Actor} from './actor';
 import {Dispatcher} from './dispatcher';
 import {workerFactory} from './web_worker';
 import {WorkerPool} from './worker_pool';
@@ -16,7 +17,7 @@ describe('Dispatcher', () => {
             }
         } as any as WorkerPool;
 
-        const dispatcher = new Dispatcher(workerPool, {}, mapId);
+        const dispatcher = new Dispatcher(workerPool, {} as any, mapId);
         expect(dispatcher.actors.map((actor) => { return actor.target; })).toEqual(workers);
         dispatcher.remove();
         expect(dispatcher.actors).toHaveLength(0);
@@ -41,7 +42,7 @@ describe('Dispatcher', () => {
             }
         } as any as WorkerPool;
 
-        let dispatcher = new Dispatcher(workerPool, {}, mapId);
+        let dispatcher = new Dispatcher(workerPool, {} as any, mapId);
         expect(dispatcher.actors.map((actor) => { return actor.target; })).toEqual(workers);
 
         // Remove dispatcher, but map is not disposed (During style change)
@@ -50,7 +51,7 @@ describe('Dispatcher', () => {
         expect(releaseCalled).toHaveLength(0);
 
         // Create new instance of dispatcher
-        dispatcher = new Dispatcher(workerPool, {}, mapId);
+        dispatcher = new Dispatcher(workerPool, {} as any, mapId);
         expect(dispatcher.actors.map((actor) => { return actor.target; })).toEqual(workers);
         dispatcher.remove(true); // mapRemoved = true
         expect(dispatcher.actors).toHaveLength(0);
@@ -61,14 +62,12 @@ describe('Dispatcher', () => {
     test('#remove destroys actors', () => {
         const actorsRemoved = [];
         const mapId = 1;
-        function Actor() {
-            this.remove = function() { actorsRemoved.push(this); };
-        }
-        jest.spyOn(Dispatcher, 'Actor').mockImplementation(Actor as any);
+        const spy = jest.fn().mockImplementation(() => { actorsRemoved.push(this); });
+        Actor.prototype.remove = spy;
         WorkerPool.workerCount = 4;
 
         const workerPool = new WorkerPool();
-        const dispatcher = new Dispatcher(workerPool, {}, mapId);
+        const dispatcher = new Dispatcher(workerPool, {} as any, mapId);
         dispatcher.remove();
         expect(actorsRemoved).toHaveLength(4);
     });

package/src/util/dispatcher.ts

@@ -1,5 +1,5 @@
 import {asyncAll} from './util';
-import {Actor} from './actor';
+import {Actor, GlyphsProvider, MessageType} from './actor';
 
 import type {WorkerPool} from './worker_pool';
 import type {WorkerSource} from '../source/worker_source'; /* eslint-disable-line */ // this is used for the docs' import
@@ -11,14 +11,9 @@ export class Dispatcher {
     workerPool: WorkerPool;
     actors: Array<Actor>;
     currentActor: number;
-    id: number;
+    id: string | number;
 
-    // exposed to allow stubbing in unit tests
-    static Actor: {
-        new (...args: any): Actor;
-    };
-
-    constructor(workerPool: WorkerPool, parent: any, mapId: number) {
+    constructor(workerPool: WorkerPool, parent: GlyphsProvider, mapId: string | number) {
         this.workerPool = workerPool;
         this.actors = [];
         this.currentActor = 0;
@@ -26,7 +21,7 @@ export class Dispatcher {
         const workers = this.workerPool.acquire(mapId);
         for (let i = 0; i < workers.length; i++) {
             const worker = workers[i];
-            const actor = new Dispatcher.Actor(worker, parent, mapId);
+            const actor = new Actor(worker, parent, mapId);
             actor.name = `Worker ${i}`;
             this.actors.push(actor);
         }
@@ -36,7 +31,7 @@ export class Dispatcher {
     /**
      * Broadcast a message to all Workers.
      */
-    broadcast(type: string, data: unknown, cb?: (...args: any[]) => any) {
+    broadcast(type: MessageType, data: unknown, cb?: (...args: any[]) => any) {
         cb = cb || function () {};
         asyncAll(this.actors, (actor, done) => {
             actor.send(type, data, done);
@@ -58,5 +53,3 @@ export class Dispatcher {
         if (mapRemoved) this.workerPool.release(this.id);
     }
 }
-
-Dispatcher.Actor = Actor;

package/src/util/web_worker.ts

@@ -2,21 +2,6 @@ import {config} from './config';
 
 import type {WorkerSource} from '../source/worker_source';
 
-export type MessageListener = (
-    a: {
-        data: any;
-        target: any;
-    }
-) => unknown;
-
-// The main thread interface. Provided by Worker in a browser environment,
-export interface WorkerInterface {
-    addEventListener(type: 'message', listener: MessageListener): void;
-    removeEventListener(type: 'message', listener: MessageListener): void;
-    postMessage(message: any): void;
-    terminate(): void;
-}
-
 export interface WorkerGlobalScopeInterface {
     importScripts(...urls: Array<string>): void;
     registerWorkerSource: (

package/src/util/web_worker_transfer.ts

@@ -172,10 +172,9 @@ export function serialize(input: unknown, transferables?: Array<Transferable> |
 
         if (!klass.serialize) {
             for (const key in input) {
-                // any cast due to https://github.com/facebook/flow/issues/5393
-                if (!(input as any).hasOwnProperty(key)) continue; // eslint-disable-line no-prototype-builtins
+                if (!input.hasOwnProperty(key)) continue; // eslint-disable-line no-prototype-builtins
                 if (registry[name].omit.indexOf(key) >= 0) continue;
-                const property = (input as any)[key];
+                const property = input[key];
                 properties[key] = registry[name].shallow.indexOf(key) >= 0 ?
                     property :
                     serialize(property, transferables);
@@ -184,7 +183,7 @@ export function serialize(input: unknown, transferables?: Array<Transferable> |
                 properties.message = input.message;
             }
         } else {
-            if (transferables && properties as any === transferables[transferables.length - 1]) {
+            if (transferables && properties === transferables[transferables.length - 1]) {
                 throw new Error('statically serialized object won\'t survive transfer of $name property');
             }
         }
@@ -226,7 +225,7 @@ export function deserialize(input: Serialized): unknown {
     }
 
     if (typeof input === 'object') {
-        const name = (input as any).$name || 'Object';
+        const name = input.$name || 'Object';
         if (!registry[name]) {
             throw new Error(`can't deserialize unregistered class ${name}`);
         }

package/src/util/worker_pool.ts

@@ -1,7 +1,7 @@
 import {workerFactory} from './web_worker';
-import type {WorkerInterface} from './web_worker';
 import {browser} from './browser';
 import {isSafari} from './util';
+import {ActorTarget} from './actor';
 
 export const PRELOAD_POOL_ID = 'mapboxgl_preloaded_worker_pool';
 
@@ -14,13 +14,13 @@ export class WorkerPool {
     active: {
         [_ in number | string]: boolean;
     };
-    workers: Array<WorkerInterface>;
+    workers: Array<ActorTarget>;
 
     constructor() {
         this.active = {};
     }
 
-    acquire(mapId: number | string): Array<WorkerInterface> {
+    acquire(mapId: number | string): Array<ActorTarget> {
         if (!this.workers) {
             // Lazily look up the value of mapboxgl.workerCount so that
             // client code has had a chance to set it.