Refactor worker source constructor

GitOrigin-RevId: 9395a79907afc6713fae980287e0d89b5f821aa0

Author: stepankuzmin

3d-style/source/tiled_3d_model_worker_source.ts

@@ -13,12 +13,12 @@ import type Actor from '../../src/util/actor';
 import type StyleLayerIndex from '../../src/style/style_layer_index';
 import type {
     WorkerSource,
+    WorkerSourceOptions,
     WorkerSourceTileRequest,
     WorkerSourceTiled3dModelRequest,
     WorkerSourceVectorTileCallback,
     WorkerSourceVectorTileResult
 } from '../../src/source/worker_source';
-import type {LoadVectorData} from '../../src/source/load_vector_tile';
 import type Projection from '../../src/geo/projection/projection';
 import type ModelStyleLayer from '../style/style_layer/model_style_layer';
 import type {ImageId} from '../../src/style-spec/expression/types/image_id';
@@ -120,7 +120,7 @@ class Tiled3dModelWorkerSource implements WorkerSource {
     brightness?: number;
     worldview: string | undefined;
 
-    constructor(actor: Actor, layerIndex: StyleLayerIndex, availableImages: ImageId[], availableModels: StyleModelMap, isSpriteLoaded: boolean, loadVectorData?: LoadVectorData, brightness?: number, worldview?: string) {
+    constructor({actor, layerIndex, availableImages, availableModels, brightness, worldview}: WorkerSourceOptions) {
         this.actor = actor;
         this.layerIndex = layerIndex;
         this.availableImages = availableImages;

src/source/geojson_worker_source.ts

@@ -10,18 +10,15 @@ import VectorTileWorkerSource from './vector_tile_worker_source';
 import {createExpression} from '../style-spec/expression/index';
 
 import type {
+    WorkerSourceOptions,
     WorkerSourceVectorTileRequest,
     WorkerSourceVectorTileCallback,
 } from '../source/worker_source';
-import type Actor from '../util/actor';
-import type StyleLayerIndex from '../style/style_layer_index';
 import type {Feature} from './geojson_wrapper';
 import type {Feature as ExpressionFeature} from '../style-spec/expression/index';
 import type {LoadVectorDataCallback} from './load_vector_tile';
 import type {RequestParameters, ResponseCallback} from '../util/ajax';
 import type {Callback} from '../types/callback';
-import type {ImageId} from '../style-spec/expression/types/image_id';
-import type {StyleModelMap} from '../style/style_mode';
 
 export type GeoJSONWorkerOptions = {
     source: string;
@@ -49,8 +46,6 @@ type ResourceTiming = Record<string, PerformanceResourceTiming[]>;
 
 export type LoadGeoJSONResult = FeatureCollectionOrFeature & {resourceTiming?: ResourceTiming};
 
-export type LoadGeoJSON = (params: LoadGeoJSONParameters, callback: ResponseCallback<LoadGeoJSONResult>) => void;
-
 export interface GeoJSONIndex {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     getTile: (z: number, x: number, y: number) => any;
@@ -111,9 +106,7 @@ function loadGeoJSONTile(this: GeoJSONWorkerSource, params: WorkerSourceVectorTi
  * The {@link WorkerSource} implementation that supports {@link GeoJSONSource}.
  * This class is designed to be easily reused to support custom source types
  * for data formats that can be parsed/converted into an in-memory GeoJSON
- * representation.  To do so, create it with
- * `new GeoJSONWorkerSource(actor, layerIndex, customLoadGeoJSONFunction)`.
- * For a full example, see [mapbox-gl-topojson](https://github.com/developmentseed/mapbox-gl-topojson).
+ * representation.
  *
  * @private
  */
@@ -122,16 +115,10 @@ class GeoJSONWorkerSource extends VectorTileWorkerSource {
     _dynamicIndex: GeoJSONRT;
 
     /**
-     * @param [loadGeoJSON] Optional method for custom loading/parsing of
-     * GeoJSON based on parameters passed from the main-thread Source.
-     * See {@link GeoJSONWorkerSource#loadGeoJSON}.
      * @private
      */
-    constructor(actor: Actor, layerIndex: StyleLayerIndex, availableImages: ImageId[], availableModels: StyleModelMap, isSpriteLoaded: boolean, loadGeoJSON?: LoadGeoJSON | null, brightness?: number | null) {
-        super(actor, layerIndex, availableImages, availableModels, isSpriteLoaded, loadGeoJSONTile, brightness);
-        if (loadGeoJSON) {
-            this.loadGeoJSON = loadGeoJSON;
-        }
+    constructor({actor, layerIndex, availableImages, availableModels, isSpriteLoaded, brightness}: WorkerSourceOptions) {
+        super({actor, layerIndex, availableImages, availableModels, isSpriteLoaded, loadTileData: loadGeoJSONTile, brightness});
         this._dynamicIndex = new GeoJSONRT();
     }
 
@@ -241,15 +228,11 @@ class GeoJSONWorkerSource extends VectorTileWorkerSource {
     }
 
     /**
-     * Fetch and parse GeoJSON according to the given params.  Calls `callback`
-     * with `(err, data)`, where `data` is a parsed GeoJSON object.
+     * Fetch and parse GeoJSON according to the given params.
      *
      * GeoJSON is loaded and parsed from `params.url` if it exists, or else
      * expected as a literal (string or object) `params.data`.
      *
-     * @param params
-     * @param [params.url] A URL to the remote GeoJSON data.
-     * @param [params.data] Literal GeoJSON data. Must be provided if `params.url` is not.
      * @private
      */
     loadGeoJSON(params: LoadGeoJSONParameters, callback: ResponseCallback<FeatureCollectionOrFeature>): void {
@@ -263,8 +246,7 @@ class GeoJSONWorkerSource extends VectorTileWorkerSource {
             // delay loading by one tick to hopefully let GC clean up the previous index (if present)
             setTimeout(() => {
                 try {
-                    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-                    return callback(null, JSON.parse(params.data));
+                    return callback(null, JSON.parse(params.data) as FeatureCollectionOrFeature);
                 } catch (e) {
                     return callback(new Error(`Input data given to '${params.source}' is not a valid GeoJSON object.`));
                 }

src/source/load_vector_tile.ts

@@ -3,6 +3,7 @@ import Protobuf from 'pbf';
 import {getArrayBuffer} from '../util/ajax';
 
 import type {Callback} from '../types/callback';
+import type {Cancelable} from '../types/cancelable';
 import type {WorkerSourceVectorTileRequest} from './worker_source';
 import type {default as Scheduler, TaskMetadata} from '../util/scheduler';
 
@@ -20,14 +21,13 @@ export type LoadVectorTileResult = {
  */
 export type LoadVectorDataCallback = Callback<LoadVectorTileResult | null | undefined>;
 
-export type LoadVectorData = (params: WorkerSourceVectorTileRequest, callback: LoadVectorDataCallback) => AbortVectorDataRequest | undefined;
+export type LoadVectorData = (params: WorkerSourceVectorTileRequest, callback: LoadVectorDataCallback) => Cancelable['cancel'];
 
-type VectorDataRequest = (callback: LoadVectorDataCallback) => AbortVectorDataRequest;
-type AbortVectorDataRequest = () => void;
+type VectorDataRequest = (callback: LoadVectorDataCallback) => Cancelable['cancel'];
 
 type DedupedRequestEntry = {
     result?: [Error | null, LoadVectorTileResult];
-    cancel?: AbortVectorDataRequest;
+    cancel?: Cancelable['cancel'];
     callbacks?: LoadVectorDataCallback[];
 };
 
@@ -40,7 +40,7 @@ export class DedupedRequest {
         this.scheduler = scheduler;
     }
 
-    request(key: string, metadata: TaskMetadata, request: VectorDataRequest, callback: LoadVectorDataCallback): AbortVectorDataRequest {
+    request(key: string, metadata: TaskMetadata, request: VectorDataRequest, callback: LoadVectorDataCallback): Cancelable['cancel'] {
         const entry = this.entries[key] = this.entries[key] || {callbacks: []};
 
         if (entry.result) {
@@ -92,7 +92,7 @@ export function loadVectorTile(
     params: WorkerSourceVectorTileRequest,
     callback: LoadVectorDataCallback,
     skipParse?: boolean,
-): AbortVectorDataRequest {
+): Cancelable['cancel'] {
     const key = JSON.stringify(params.request);
 
     const makeRequest: VectorDataRequest = (callback: LoadVectorDataCallback) => {

src/source/raster_array_tile_worker_source.ts

@@ -9,6 +9,7 @@ import type {ActorMessages} from '../util/actor_messages';
 import type {OverscaledTileID} from './tile_id';
 import type {
     WorkerSource,
+    WorkerSourceOptions,
     WorkerSourceTileRequest,
     WorkerSourceRasterArrayTileRequest,
     WorkerSourceRasterArrayTileCallback,
@@ -79,7 +80,7 @@ class RasterArrayTileWorkerSource implements WorkerSource {
     loading: Record<number, RasterArrayWorkerTile>;
     loaded: Record<number, RasterArrayWorkerTile>;
 
-    constructor(actor: Actor) {
+    constructor({actor}: WorkerSourceOptions) {
         this.actor = actor;
         this.loading = {};
         this.loaded = {};

src/source/raster_dem_tile_worker_source.ts

@@ -1,6 +1,5 @@
 import DEMData from '../data/dem_data';
 
-import type Actor from '../util/actor';
 import type {
     WorkerSource,
     WorkerSourceTileRequest,
@@ -10,7 +9,6 @@ import type {
 } from './worker_source';
 
 class RasterDEMTileWorkerSource implements WorkerSource {
-    actor: Actor;
     offscreenCanvas: OffscreenCanvas;
     offscreenCanvasContext: OffscreenCanvasRenderingContext2D;
 

src/source/vector_tile_worker_source.ts

@@ -8,6 +8,7 @@ import {getExpiryDataFromHeaders} from '../util/util';
 
 import type {
     WorkerSource,
+    WorkerSourceOptions,
     WorkerSourceTileRequest,
     WorkerSourceVectorTileRequest,
     WorkerSourceVectorTileResult,
@@ -25,8 +26,7 @@ import type {StyleModelMap} from '../style/style_mode';
  * The {@link WorkerSource} implementation that supports {@link VectorTileSource}.
  * This class is designed to be easily reused to support custom source types
  * for data formats that can be parsed/converted into an in-memory VectorTile
- * representation.  To do so, create it with
- * `new VectorTileWorkerSource(actor, styleLayers, customLoadVectorDataFunction)`.
+ * representation.
  *
  * @private
  */
@@ -41,22 +41,18 @@ class VectorTileWorkerSource extends Evented implements WorkerSource {
     deduped: DedupedRequest;
     isSpriteLoaded: boolean;
     scheduler?: Scheduler | null;
-    brightness?: number | null;
+    brightness?: number;
 
     /**
-     * @param [loadVectorData] Optional method for custom loading of a VectorTile
-     * object based on parameters passed from the main-thread Source. See
-     * {@link VectorTileWorkerSource#loadTile}. The default implementation simply
-     * loads the pbf at `params.url`.
      * @private
      */
-    constructor(actor: Actor, layerIndex: StyleLayerIndex, availableImages: ImageId[], availableModels: StyleModelMap, isSpriteLoaded: boolean, loadVectorData?: LoadVectorData | null, brightness?: number | null) {
+    constructor({actor, layerIndex, availableImages, availableModels, isSpriteLoaded, loadTileData, brightness}: WorkerSourceOptions) {
         super();
         this.actor = actor;
         this.layerIndex = layerIndex;
         this.availableImages = availableImages;
         this.availableModels = availableModels;
-        this.loadVectorData = loadVectorData || loadVectorTile;
+        this.loadVectorData = (loadTileData as LoadVectorData) || loadVectorTile;
         this.loading = {};
         this.loaded = {};
         this.deduped = new DedupedRequest(actor.scheduler);

src/source/worker.ts

@@ -61,7 +61,7 @@ export default class MapWorker {
     referrer: string | null | undefined;
     dracoUrl: string | null | undefined;
     meshoptUrl: string | null | undefined;
-    brightness: number | null | undefined;
+    brightness: number | undefined;
     imageRasterizer: ImageRasterizer;
     worldview: string | undefined;
     rtlPluginParsingListeners: Array<Callback<boolean>>;
@@ -397,17 +397,21 @@ export default class MapWorker {
                 scheduler: this.actor.scheduler
             } as Actor;
 
-            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call
-            workerSources[mapId][scope][type][source] = new this.workerSourceTypes[type](
+            const WorkerSourceConstructor = this.workerSourceTypes[type as WorkerSourceType];
+            if (!WorkerSourceConstructor) {
+                throw new Error(`Unknown worker source type "${type}".`);
+            }
+
+            workerSources[mapId][scope][type][source] = new WorkerSourceConstructor({
                 actor,
-                this.getLayerIndex(mapId, scope),
-                this.getAvailableImages(mapId, scope),
-                this.getAvailableModels(mapId, scope),
-                this.isSpriteLoaded[mapId][scope],
-                undefined,
-                this.brightness,
-                this.worldview
-            );
+                layerIndex: this.getLayerIndex(mapId, scope),
+                availableImages: this.getAvailableImages(mapId, scope),
+                availableModels: this.getAvailableModels(mapId, scope),
+                isSpriteLoaded: this.isSpriteLoaded[mapId][scope],
+                loadTileData: undefined,
+                brightness: this.brightness,
+                worldview: this.worldview
+            });
         }
 
         return workerSources[mapId][scope][type][source];

src/source/worker_source.ts

@@ -25,6 +25,7 @@ import type {ImageId} from '../style-spec/expression/types/image_id';
 import type {StringifiedImageVariant} from '../style-spec/expression/types/image_variant';
 import type {StyleModelMap} from '../style/style_mode';
 import type {IndoorTileOptions} from '../style/indoor_data.js';
+import type {Cancelable} from '../types/cancelable';
 
 /**
  * The parameters passed to the {@link MapWorker#getWorkerSource}.
@@ -162,14 +163,6 @@ export type WorkerSourceImageRaserizeCallback = Callback<RasterizedImageMap>;
  *
  * @see {@link Map#addSourceType}
  * @private
- *
- * @class WorkerSource
- * @param actor
- * @param layerIndex
- * @param availableImages
- * @param isSpriteLoaded
- * @param loadData
- * @param brightness
  */
 export interface WorkerSource {
     availableImages?: ImageId[];
@@ -202,15 +195,19 @@ export interface WorkerSource {
     removeSource?: (params: {source: string}, callback: Callback<void>) => void;
 }
 
+export type WorkerSourceLoadTileData = (params: WorkerSourceTileRequest, callback: Callback<unknown>) => Cancelable['cancel'];
+
+export type WorkerSourceOptions = {
+    actor: Actor;
+    layerIndex: StyleLayerIndex;
+    availableImages: ImageId[];
+    availableModels: StyleModelMap;
+    isSpriteLoaded: boolean;
+    loadTileData?: WorkerSourceLoadTileData;
+    brightness?: number;
+    worldview?: string;
+};
+
 export interface WorkerSourceConstructor {
-    new(
-        actor?: Actor,
-        layerIndex?: StyleLayerIndex,
-        availableImages?: ImageId[],
-        availableModels?: StyleModelMap,
-        isSpriteLoaded?: boolean,
-        loadData?: (params: {source: string; scope: string}, callback: Callback<unknown>) => () => void | undefined,
-        brightness?: number,
-        worldview?: string
-    ): WorkerSource;
+    new(options: WorkerSourceOptions): WorkerSource;
 }

test/unit/source/geojson_worker_source.test.ts

@@ -19,7 +19,7 @@ describe('reloadTile', () => {
             }
         ];
         const layerIndex = new StyleLayerIndex(layers);
-        const source = new GeoJSONWorkerSource(actor, layerIndex, [], [], true);
+        const source = new GeoJSONWorkerSource({actor, layerIndex, availableImages: [], availableModels: [], isSpriteLoaded: true});
         const originalLoadVectorData = source.loadVectorData;
         let loadVectorCallCount = 0;
         source.loadVectorData = function (params, callback) {
@@ -131,7 +131,8 @@ describe('resourceTiming', () => {
         vi.spyOn(perf, 'getEntriesByName').mockImplementation(() => { return [exampleResourceTiming]; });
 
         const layerIndex = new StyleLayerIndex(layers);
-        const source = new GeoJSONWorkerSource(actor, layerIndex, [], [], true, (params, callback) => { return callback(null, geoJson); });
+        const source = new GeoJSONWorkerSource({actor, layerIndex, availableImages: [], availableModels: [], isSpriteLoaded: true});
+        source.loadGeoJSON = (params, callback) => { return callback(null, geoJson); };
 
         source.loadData({source: 'testSource', request: {url: 'http://localhost/nonexistent', collectResourceTiming: true}}, (err, result) => {
             expect(err).toEqual(null);
@@ -141,7 +142,7 @@ describe('resourceTiming', () => {
 
     test('loadData - data', () => {
         const layerIndex = new StyleLayerIndex(layers);
-        const source = new GeoJSONWorkerSource(actor, layerIndex, [], [], true);
+        const source = new GeoJSONWorkerSource({actor, layerIndex, availableImages: [], availableModels: [], isSpriteLoaded: true});
 
         source.loadData({source: 'testSource', data: JSON.stringify(geoJson)}, (err, result) => {
             expect(err).toEqual(null);

test/unit/source/raster_dem_tile_worker_source.test.ts

@@ -2,12 +2,11 @@
 // @ts-nocheck
 import {describe, test, expect} from '../../util/vitest';
 import RasterDEMTileWorkerSource from '../../../src/source/raster_dem_tile_worker_source';
-import StyleLayerIndex from '../../../src/style/style_layer_index';
 import DEMData from '../../../src/data/dem_data';
 
 describe('loadTile', () => {
     test('loads DEM tile', () => {
-        const source = new RasterDEMTileWorkerSource(null, new StyleLayerIndex());
+        const source = new RasterDEMTileWorkerSource();
 
         source.loadTile({
             source: 'source',