Simplify Actor and Dispatcher APIs

GitOrigin-RevId: 57ca9eb8f983d41ab6fb46db103f631f7e31662a

Author: stepankuzmin

3d-style/source/indoor_parser.ts

@@ -16,7 +16,7 @@ export function parseActiveFloors(data: VectorTile, indoorTileOptions: IndoorTil
     const sourceLayers = calculateIndoorSourceLayers(indoorTileOptions.sourceLayers, new Set(Object.keys(data.layers)));
     const indoorState = indoorTileOptions.indoorState;
     const indoorData = parseData(data, sourceLayers, indoorState.activeFloors, indoorState.selectedFloorId, tileID);
-    actor.send('setIndoorData', indoorData, {skipResult: true});
+    actor.notify('setIndoorData', indoorData);
     return activeFloorsVisible ? indoorData.activeFloors : undefined;
 }
 

3d-style/source/tiled_3d_model_source.ts

@@ -218,7 +218,7 @@ class Tiled3DModelSource extends Evented<SourceEvents> implements ISource {
             delete tile.request;
         }
         if (tile.actor) {
-            tile.actor.send('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+            tile.actor.notify('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         }
     }
 

src/source/geojson_source.ts

@@ -422,7 +422,7 @@ class GeoJSONSource extends Evented<SourceEvents> implements ISource {
 
             // The runtime type is `${this.type}.loadData` so geojson-like source types can reuse
             // this path, but every variant returns a LoadGeoJSONResult-shaped reply.
-            const result = await this.actor.send(`${this.type}.loadData` as 'geojson.loadData', options, {signal: controller.signal});
+            const result = await this.actor.send(`${this.type}.loadData`, options, {signal: controller.signal});
             this._loaded = true;
             this._pendingLoad = null;
             // although GeoJSON sources contain no metadata, we fire this event at first
@@ -544,7 +544,7 @@ class GeoJSONSource extends Evented<SourceEvents> implements ISource {
     }
 
     unloadTile(tile: Tile, _?: Callback<undefined> | null) {
-        this.actor.send('removeTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+        this.actor.notify('removeTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         tile.destroy();
     }
 

src/source/raster_array_tile_source.ts

@@ -167,7 +167,7 @@ class RasterArrayTileSource extends RasterTileSource<'raster-array'> {
         }
 
         if (tile.actor) {
-            tile.actor.send('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+            tile.actor.notify('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         }
     }
 

src/source/raster_dem_tile_source.ts

@@ -36,15 +36,15 @@ class RasterDEMTileSource extends RasterTileSource<'raster-dem'> {
             const {request, options} = await parseTileJSONRequest(this._options, this.map._requestManager, controller.signal);
             if (controller.signal.aborted) return;
 
-            const results = await this.dispatcher.broadcast('loadTileProvider', {
+            const results = await this.dispatcher.send('loadTileProvider', {
                 name: tileProvider.name,
                 url: tileProvider.url,
                 source: this.id,
                 scope: this.scope,
                 type: this.type,
                 options,
                 request,
-            }, {keepResult: true, signal: controller.signal});
+            }, {signal: controller.signal});
 
             if (controller.signal.aborted) return;
 
@@ -129,7 +129,7 @@ class RasterDEMTileSource extends RasterTileSource<'raster-dem'> {
             delete tile.request;
         }
         if (tile.actor) {
-            tile.actor.send('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+            tile.actor.notify('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         }
         if (callback) callback();
     }

src/source/vector_tile_source.ts

@@ -181,15 +181,15 @@ class VectorTileSource extends Evented<SourceEvents> implements ISource<'vector'
             const {request, options} = await parseTileJSONRequest(this._options, this.map._requestManager, controller.signal);
             if (controller.signal.aborted) return;
 
-            const results = await this.dispatcher.broadcast('loadTileProvider', {
+            const results = await this.dispatcher.send('loadTileProvider', {
                 name: tileProvider.name,
                 url: tileProvider.url,
                 source: this.id,
                 scope: this.scope,
                 type: this.type,
                 options,
                 request,
-            }, {keepResult: true, signal: controller.signal});
+            }, {signal: controller.signal});
 
             if (controller.signal.aborted) return;
 
@@ -507,13 +507,13 @@ class VectorTileSource extends Evented<SourceEvents> implements ISource<'vector'
             delete tile.request;
         }
         if (tile.actor) {
-            tile.actor.send('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+            tile.actor.notify('abortTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         }
     }
 
     unloadTile(tile: Tile, _?: Callback<undefined> | null) {
         if (tile.actor) {
-            tile.actor.send('removeTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope}, {skipResult: true});
+            tile.actor.notify('removeTile', {uid: tile.uid, type: this.type, source: this.id, scope: this.scope});
         }
         tile.destroy();
     }

src/source/worker_source.ts

@@ -231,7 +231,7 @@ export interface WorkerSource {
  * `Pick` so the signatures can't drift. Worker sources only send back to the
  * main thread, hence `Actor<MainInbox>`.
  */
-export type WorkerSourceActor = Pick<Actor<MainInbox>, 'send' | 'sendCancelable' | 'scheduler'>;
+export type WorkerSourceActor = Pick<Actor<MainInbox>, 'send' | 'notify' | 'sendCancelable' | 'scheduler'>;
 
 export type WorkerSourceOptions = {
     actor: WorkerSourceActor;

src/style/style.ts

@@ -564,8 +564,8 @@ class Style extends Evented<MapEvents> {
                 pluginStatus: event.pluginStatus,
                 pluginURL: event.pluginURL
             };
-            self.dispatcher.broadcast('syncRTLPluginState', state, {keepResult: true})
-                .then((results: boolean[]) => {
+            self.dispatcher.send('syncRTLPluginState', state)
+                .then((results) => {
                     triggerPluginCompletionEvent(null);
                     const allComplete = results.every((elem) => elem);
                     if (allComplete) {

src/util/actor.ts

@@ -17,7 +17,6 @@ export type Task = {
     error?: Serialized;
     targetMapId?: number;
     sourceMapId?: number;
-    skipResult?: boolean;
 };
 
 type PendingResponse = {
@@ -82,18 +81,17 @@ class Actor<Outbox extends MessageMap> {
     }
 
     /**
-     * Sends a message from a main-thread map to a Worker or from a Worker back to
-     * a main-thread map instance.
+     * Sends a message from a main-thread map to a Worker or from a Worker back to a
+     * main-thread map instance, and resolves with the worker's result. Registers a pending
+     * response and is cancelable via `signal`. Use {@link Actor#notify} if you don't need a response.
      *
      * @param type The name of the target method to invoke or '[source-type].[source-name].name' for a method on a WorkerSource.
      * @param data The message payload.
-     * @param options Optional send options. When `skipResult: true`, the worker skips posting a response and the call returns void.
+     * @param options Optional send options (`signal` to cancel, `targetMapId`, scheduler `metadata`).
      * @private
      */
-    send<T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options: {skipResult: true; targetMapId?: number}): void;
-    send<T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {signal?: AbortSignal; targetMapId?: number; metadata?: TaskMetadata}): Promise<Outbox[T]['result']>;
-    send<T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {signal?: AbortSignal; targetMapId?: number; metadata?: TaskMetadata; skipResult?: boolean}): Promise<Outbox[T]['result']> | void {
-        const {signal, targetMapId, metadata, skipResult = false} = options || {};
+    send<T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {signal?: AbortSignal; targetMapId?: number; metadata?: TaskMetadata}): Promise<Outbox[T]['result']> {
+        const {signal, targetMapId, metadata} = options || {};
         // 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
         // message from multiple other actors which could run in different execution context. A
@@ -109,13 +107,10 @@ class Actor<Outbox extends MessageMap> {
             id,
             type: type as ActorMessage,
             targetMapId,
-            skipResult,
             sourceMapId: this.mapId,
             data: serialize(data, buffers)
         }, [...buffers]);
 
-        if (skipResult) return;
-
         return new Promise((resolve, reject) => {
             const entry: PendingResponse = {resolve, reject, metadata: metadata || DEFAULT_METADATA};
 
@@ -132,6 +127,22 @@ class Actor<Outbox extends MessageMap> {
         });
     }
 
+    /**
+     * Sends a message without awaiting for response. Use {@link Actor#send} if you need to await a response.
+     * @private
+     */
+    notify<T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {targetMapId?: number}): void {
+        const {targetMapId} = options || {};
+        const buffers: Set<Transferable> = new Set();
+
+        this.target.postMessage({
+            type: type as ActorMessage,
+            targetMapId,
+            sourceMapId: this.mapId,
+            data: serialize(data, buffers)
+        }, [...buffers]);
+    }
+
     /**
      * Convenience wrapper around {@link send} for the common callback + cancellation pattern:
      * fires the message with a fresh AbortController, routes the result to a node-style callback,
@@ -158,12 +169,15 @@ class Actor<Outbox extends MessageMap> {
      * must carry the owning map's id as `targetMapId`.
      * @private
      */
-    getWorkerSourceActor(mapId: number): Pick<Actor<Outbox>, 'send' | 'sendCancelable' | 'scheduler'> {
+    getWorkerSourceActor(mapId: number): Pick<Actor<Outbox>, 'send' | 'notify' | 'sendCancelable' | 'scheduler'> {
         return {
             scheduler: this.scheduler,
-            send: <T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {signal?: AbortSignal; metadata?: TaskMetadata; skipResult?: boolean}) => {
+            send: <T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options?: {signal?: AbortSignal; metadata?: TaskMetadata}) => {
                 return this.send(type, data, {...options, targetMapId: mapId});
             },
+            notify: <T extends keyof Outbox>(type: T, data: Outbox[T]['params']) => {
+                this.notify(type, data, {targetMapId: mapId});
+            },
             sendCancelable: <T extends keyof Outbox>(type: T, data: Outbox[T]['params'], options: {metadata?: TaskMetadata}, callback: (err?: Error | null, result?: Outbox[T]['result']) => void) => {
                 return this.sendCancelable(type, data, {...options, targetMapId: mapId}, callback);
             },
@@ -175,8 +189,6 @@ class Actor<Outbox extends MessageMap> {
         if (!data) return;
 
         const id = data.id;
-        if (!id) return;
-
         if (data.targetMapId && this.mapId !== data.targetMapId) {
             return;
         }
@@ -221,47 +233,51 @@ class Actor<Outbox extends MessageMap> {
                     entry.reject(err as Error);
                 }
             }
-        } else {
-            const buffers: Set<Transferable> = new Set();
-            const params = deserialize(task.data);
 
-            // `task.type` is a message name ('loadTile', etc.) or a runtime
-            // `sourcetype.method` (WorkerSource types register via Map#addSourceType).
-            // Both dispatch by runtime string, so the handler lookup is untyped.
-            try {
-                let result: unknown;
-                if (this.parent[task.type]) {
-                    // task.type == 'loadTile', 'removeTile', etc.
-                    result = await this.parent[task.type](task.sourceMapId, params);
-                } else if (this.parent.getWorkerSource) {
-                    // task.type == sourcetype.method
-                    const keys = task.type.split('.');
-                    const {source, scope} = params as {source: string; scope: string};
-                    const workerSource = this.parent.getWorkerSource(task.sourceMapId, {type: keys[0], source, scope, uid: 0});
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
-                    result = await workerSource[keys[1]](params);
-                } else {
-                    throw new Error(`Could not find function ${task.type}`);
-                }
-                if (!task.skipResult) {
-                    this.target.postMessage({
-                        id,
-                        type: '<response>',
-                        sourceMapId: this.mapId,
-                        error: null,
-                        data: serialize(result, buffers)
-                    }, [...buffers]);
-                }
-            } catch (err) {
-                assert(!task.skipResult, 'Tasks that skip results should not throw errors');
-                this.target.postMessage({
-                    id,
-                    type: '<response>',
-                    sourceMapId: this.mapId,
-                    error: serialize(err),
-                    data: null
-                }, []);
+            return;
+        }
+
+        const buffers: Set<Transferable> = new Set();
+        const params = deserialize(task.data);
+
+        // `task.type` is a message name ('loadTile', etc.) or a runtime
+        // `sourcetype.method` (WorkerSource types register via Map#addSourceType).
+        // Both dispatch by runtime string, so the handler lookup is untyped.
+        try {
+            let result: unknown;
+            if (this.parent[task.type]) {
+                // task.type == 'loadTile', 'removeTile', etc.
+                result = await this.parent[task.type](task.sourceMapId, params);
+            } else if (this.parent.getWorkerSource) {
+                // task.type == sourcetype.method
+                const keys = task.type.split('.');
+                const {source, scope} = params as {source: string; scope: string};
+                const workerSource = this.parent.getWorkerSource(task.sourceMapId, {type: keys[0], source, scope, uid: 0});
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+                result = await workerSource[keys[1]](params);
+            } else {
+                throw new Error(`Could not find function ${task.type}`);
             }
+
+            if (!id) return;
+
+            this.target.postMessage({
+                id,
+                type: '<response>',
+                sourceMapId: this.mapId,
+                error: null,
+                data: serialize(result, buffers)
+            }, [...buffers]);
+        } catch (err) {
+            if (!id) assert(false, `"${task.type}" threw: ${(err as Error).message}`);
+
+            this.target.postMessage({
+                id,
+                type: '<response>',
+                sourceMapId: this.mapId,
+                error: serialize(err),
+                data: null
+            }, []);
         }
     }
 

src/util/dispatcher.ts

@@ -41,29 +41,30 @@ class Dispatcher {
         // track whether all workers are instantiated and ready to receive messages;
         // used for optimizations on initial map load
         this.ready = false;
-        this.broadcast('checkIfReady', null, {keepResult: true}).then(() => { this.ready = true; }).catch(() => {});
+        this.send('checkIfReady', null).then(() => { this.ready = true; }).catch(() => {});
     }
 
     /**
-     * Broadcast a message to all Workers.
-     *
-     * By default, broadcasts are fire-and-forget and return `void`. Pass `{keepResult: true}` to
-     * receive a Promise that resolves with the array of per-worker results (or rejects if any worker rejects).
+     * Sends a message to every Worker and resolves with the per-worker results in actor order.
+     * Use {@link Dispatcher#broadcast} when you don't need the results.
      *
      * @private
      */
-    broadcast<T extends keyof WorkerInbox>(type: T, data: WorkerInbox[T]['params'], options: {keepResult: true; signal?: AbortSignal}): Promise<Array<WorkerInbox[T]['result']>>;
-    broadcast<T extends keyof WorkerInbox>(type: T, data?: WorkerInbox[T]['params']): void;
-    broadcast<T extends keyof WorkerInbox>(type: T, data?: WorkerInbox[T]['params'], options?: {keepResult?: boolean; signal?: AbortSignal}): Promise<Array<WorkerInbox[T]['result']>> | void {
+    send<T extends keyof WorkerInbox>(type: T, data: WorkerInbox[T]['params'], options?: {signal?: AbortSignal}): Promise<Array<WorkerInbox[T]['result']>> {
         assert(this.actors.length);
-        const {signal, keepResult = false} = options || {};
-
-        if (keepResult) {
-            return Promise.all(this.actors.map(actor => actor.send(type, data, {signal})));
-        }
+        return Promise.all(this.actors.map(actor => actor.send(type, data, options)));
+    }
 
+    /**
+     * Broadcasts a fire-and-forget message to every Worker.
+     * Use {@link Dispatcher#send} when you need the results.
+     *
+     * @private
+     */
+    broadcast<T extends keyof WorkerInbox>(type: T, data?: WorkerInbox[T]['params']): void {
+        assert(this.actors.length);
         for (const actor of this.actors) {
-            actor.send(type, data, {skipResult: true});
+            actor.notify(type, data);
         }
     }