@scoova/mgl 1.0.0

package/src/source/geojson_worker_source.test.ts

@@ -0,0 +1,399 @@
+import {GeoJSONWorkerSource, LoadGeoJSONParameters} from './geojson_worker_source';
+import {StyleLayerIndex} from '../style/style_layer_index';
+import {OverscaledTileID} from './tile_id';
+import perf from '../util/performance';
+import {LayerSpecification} from '@maplibre/maplibre-gl-style-spec';
+import {Actor} from '../util/actor';
+import {WorkerTileParameters} from './worker_source';
+import {setPerformance, sleep} from '../util/test/util';
+import {type FakeServer, fakeServer} from 'nise';
+
+const actor = {send: () => {}} as any as Actor;
+
+beforeEach(() => {
+    setPerformance();
+});
+
+describe('reloadTile', () => {
+    test('does not rebuild vector data unless data has changed', async () => {
+        const layers = [
+            {
+                id: 'mylayer',
+                source: 'sourceId',
+                type: 'symbol',
+            }
+        ] as LayerSpecification[];
+        const layerIndex = new StyleLayerIndex(layers);
+        const source = new GeoJSONWorkerSource(actor, layerIndex, []);
+        const spy = jest.spyOn(source, 'loadVectorTile');
+        const geoJson = {
+            'type': 'Feature',
+            'geometry': {
+                'type': 'Point',
+                'coordinates': [0, 0]
+            }
+        };
+        const tileParams = {
+            source: 'sourceId',
+            uid: 0,
+            tileID: new OverscaledTileID(0, 0, 0, 0, 0),
+            maxZoom: 10
+        };
+
+        await source.loadData({source: 'sourceId', data: JSON.stringify(geoJson)} as LoadGeoJSONParameters);
+
+        // first call should load vector data from geojson
+        const firstData = await source.reloadTile(tileParams as any as WorkerTileParameters);
+        expect(spy).toHaveBeenCalledTimes(1);
+
+        // second call won't give us new rawTileData
+        let data = await source.reloadTile(tileParams as any as WorkerTileParameters);
+        expect('rawTileData' in data).toBeFalsy();
+        data.rawTileData = firstData.rawTileData;
+        expect(data).toEqual(firstData);
+
+        // also shouldn't call loadVectorData again
+        expect(spy).toHaveBeenCalledTimes(1);
+
+        // replace geojson data
+        await source.loadData({source: 'sourceId', data: JSON.stringify(geoJson)} as LoadGeoJSONParameters);
+
+        // should call loadVectorData again after changing geojson data
+        data = await source.reloadTile(tileParams as any as WorkerTileParameters);
+        expect('rawTileData' in data).toBeTruthy();
+        expect(data).toEqual(firstData);
+        expect(spy).toHaveBeenCalledTimes(2);
+    });
+
+});
+
+describe('resourceTiming', () => {
+
+    const layers = [
+        {
+            id: 'mylayer',
+            source: 'sourceId',
+            type: 'symbol',
+        }
+    ] as LayerSpecification[];
+    const geoJson = {
+        'type': 'Feature',
+        'geometry': {
+            'type': 'Point',
+            'coordinates': [0, 0]
+        }
+    } as GeoJSON.GeoJSON;
+
+    test('loadData - url', async () => {
+        const exampleResourceTiming = {
+            connectEnd: 473,
+            connectStart: 473,
+            decodedBodySize: 86494,
+            domainLookupEnd: 473,
+            domainLookupStart: 473,
+            duration: 341,
+            encodedBodySize: 52528,
+            entryType: 'resource',
+            fetchStart: 473.5,
+            initiatorType: 'xmlhttprequest',
+            name: 'http://localhost:2900/fake.geojson',
+            nextHopProtocol: 'http/1.1',
+            redirectEnd: 0,
+            redirectStart: 0,
+            requestStart: 477,
+            responseEnd: 815,
+            responseStart: 672,
+            secureConnectionStart: 0
+        } as any as PerformanceEntry;
+
+        window.performance.getEntriesByName = jest.fn().mockReturnValue([exampleResourceTiming]);
+
+        const layerIndex = new StyleLayerIndex(layers);
+        const source = new GeoJSONWorkerSource(actor, layerIndex, []);
+        source.loadGeoJSON = () => Promise.resolve(geoJson);
+
+        const result = await source.loadData({source: 'testSource', request: {url: 'http://localhost/nonexistent', collectResourceTiming: true}} as LoadGeoJSONParameters);
+
+        expect(result.resourceTiming.testSource).toEqual([exampleResourceTiming]);
+    });
+
+    test('loadData - url (resourceTiming fallback method)', async () => {
+        const sampleMarks = [100, 350];
+        const marks = {};
+        const measures = {};
+        window.performance.getEntriesByName = jest.fn().mockImplementation((name) => { return measures[name] || []; });
+        jest.spyOn(perf, 'mark').mockImplementation((name) => {
+            marks[name] = sampleMarks.shift();
+            return null;
+        });
+        window.performance.measure = jest.fn().mockImplementation((name, start, end) => {
+            measures[name] = measures[name] || [];
+            measures[name].push({
+                duration: marks[end] - marks[start],
+                entryType: 'measure',
+                name,
+                startTime: marks[start]
+            });
+            return null;
+        });
+        jest.spyOn(perf, 'clearMarks').mockImplementation(() => { return null; });
+        jest.spyOn(perf, 'clearMeasures').mockImplementation(() => { return null; });
+
+        const layerIndex = new StyleLayerIndex(layers);
+        const source = new GeoJSONWorkerSource(actor, layerIndex, []);
+        source.loadGeoJSON = () => Promise.resolve(geoJson);
+
+        const result = await source.loadData({source: 'testSource', request: {url: 'http://localhost/nonexistent', collectResourceTiming: true}} as LoadGeoJSONParameters);
+
+        expect(result.resourceTiming.testSource).toEqual(
+            [{'duration': 250, 'entryType': 'measure', 'name': 'http://localhost/nonexistent', 'startTime': 100}]
+        );
+    });
+
+    test('loadData - data', async () => {
+        const layerIndex = new StyleLayerIndex(layers);
+        const source = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        const result = await source.loadData({source: 'testSource', data: JSON.stringify(geoJson)} as LoadGeoJSONParameters);
+        expect(result.resourceTiming).toBeUndefined();
+    });
+
+});
+
+describe('loadData', () => {
+    let server: FakeServer;
+    beforeEach(() => {
+        global.fetch = null;
+        server = fakeServer.create();
+    });
+    afterEach(() => {
+        server.restore();
+    });
+
+    const layers = [
+        {
+            id: 'layer1',
+            source: 'source1',
+            type: 'symbol',
+        },
+        {
+            id: 'layer2',
+            source: 'source2',
+            type: 'symbol',
+        }
+    ] as LayerSpecification[];
+
+    const geoJson = {
+        'type': 'Feature',
+        'geometry': {
+            'type': 'Point',
+            'coordinates': [0, 0]
+        }
+    } as GeoJSON.GeoJSON;
+
+    const updateableGeoJson = {
+        type: 'Feature',
+        id: 'point',
+        geometry: {
+            type: 'Point',
+            coordinates: [0, 0],
+        },
+        properties: {},
+    } as GeoJSON.GeoJSON;
+
+    const layerIndex = new StyleLayerIndex(layers);
+    function createWorker() {
+        return new GeoJSONWorkerSource(actor, layerIndex, []);
+    }
+
+    test('abandons previous requests', async () => {
+        const worker = createWorker();
+
+        server.respondWith(request => {
+            request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify(geoJson));
+        });
+
+        const p1 = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+        await sleep(0);
+
+        const p2 = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+
+        await sleep(0);
+
+        server.respond();
+
+        const firstCallResult = await p1;
+        expect(firstCallResult && firstCallResult.abandoned).toBeTruthy();
+        const result = await p2;
+        expect(result && result.abandoned).toBeFalsy();
+    });
+
+    test('removeSource aborts requests', async () => {
+        const worker = createWorker();
+
+        server.respondWith(request => {
+            request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify(geoJson));
+        });
+
+        const loadPromise = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+        await sleep(0);
+        const removePromise = worker.removeSource({source: 'source1', type: 'type'});
+        await sleep(0);
+
+        server.respond();
+
+        const result = await loadPromise;
+        expect(result && result.abandoned).toBeTruthy();
+        await removePromise;
+    });
+
+    test('loadData with geojson creates an non-updateable source', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        await worker.loadData({source: 'source1', data: JSON.stringify(geoJson)} as LoadGeoJSONParameters);
+        await expect(worker.loadData({source: 'source1', dataDiff: {removeAll: true}} as LoadGeoJSONParameters)).rejects.toBeDefined();
+    });
+
+    test('loadData with geojson creates an updateable source', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        await worker.loadData({source: 'source1', data: JSON.stringify(updateableGeoJson)} as LoadGeoJSONParameters);
+        await expect(worker.loadData({source: 'source1', dataDiff: {removeAll: true}} as LoadGeoJSONParameters)).resolves.toBeDefined();
+    });
+
+    test('loadData with geojson network call creates an updateable source', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        server.respondWith(request => {
+            request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify(updateableGeoJson));
+        });
+
+        const load1Promise = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+        server.respond();
+
+        await load1Promise;
+        await expect(worker.loadData({source: 'source1', dataDiff: {removeAll: true}} as LoadGeoJSONParameters)).resolves.toBeDefined();
+    });
+
+    test('loadData with geojson network call creates a non-updateable source', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        server.respondWith(request => {
+            request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify(geoJson));
+        });
+
+        const promise = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+
+        server.respond();
+
+        await promise;
+
+        await expect(worker.loadData({source: 'source1', dataDiff: {removeAll: true}} as LoadGeoJSONParameters)).rejects.toBeDefined();
+    });
+
+    test('loadData with diff updates', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        await worker.loadData({source: 'source1', data: JSON.stringify(updateableGeoJson)} as LoadGeoJSONParameters);
+        await expect(worker.loadData({source: 'source1', dataDiff: {
+            add: [{
+                type: 'Feature',
+                id: 'update_point',
+                geometry: {type: 'Point', coordinates: [0, 0]},
+                properties: {}
+            }]
+        }} as LoadGeoJSONParameters)).resolves.toBeDefined();
+    });
+});
+
+describe('getData', () => {
+    let server: FakeServer;
+    beforeEach(() => {
+        global.fetch = null;
+        server = fakeServer.create();
+    });
+    afterEach(() => {
+        server.restore();
+    });
+
+    const layers = [
+        {
+            id: 'layer1',
+            source: 'source1',
+            type: 'symbol',
+        },
+        {
+            id: 'layer2',
+            source: 'source2',
+            type: 'symbol',
+        }
+    ] as LayerSpecification[];
+
+    const geoJson = {
+        'type': 'Feature',
+        'geometry': {
+            'type': 'Point',
+            'coordinates': [0, 0]
+        }
+    } as GeoJSON.GeoJSON;
+
+    const updateableGeoJson = {
+        type: 'Feature',
+        id: 'point',
+        geometry: {
+            type: 'Point',
+            coordinates: [0, 0],
+        },
+        properties: {},
+    } as GeoJSON.GeoJSON;
+
+    const layerIndex = new StyleLayerIndex(layers);
+
+    test('getData returns correct geojson when the source was loaded with geojson', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        await worker.loadData({source: 'source1', data: JSON.stringify(geoJson)} as LoadGeoJSONParameters);
+        await expect(worker.getData()).resolves.toStrictEqual(geoJson);
+    });
+
+    test('getData after a geojson network call returns actual loaded geojson', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        server.respondWith(request => {
+            request.respond(200, {'Content-Type': 'application/json'}, JSON.stringify(updateableGeoJson));
+        });
+
+        const load1Promise = worker.loadData({source: 'source1', request: {url: ''}} as LoadGeoJSONParameters);
+        server.respond();
+
+        await load1Promise;
+        await expect(worker.getData()).resolves.toStrictEqual(updateableGeoJson);
+    });
+
+    test('getData after diff updates returns updated geojson', async () => {
+        const worker = new GeoJSONWorkerSource(actor, layerIndex, []);
+
+        await worker.loadData({source: 'source1', data: JSON.stringify(updateableGeoJson)} as LoadGeoJSONParameters);
+        await expect(worker.loadData({source: 'source1', dataDiff: {
+            add: [{
+                type: 'Feature',
+                id: 'update_point',
+                geometry: {type: 'Point', coordinates: [0, 0]},
+                properties: {}
+            }]
+        }} as LoadGeoJSONParameters)).resolves.toBeDefined();
+
+        await expect(worker.getData()).resolves.toStrictEqual({
+            type: 'FeatureCollection',
+            features: [
+                {...updateableGeoJson},
+                {
+                    type: 'Feature',
+                    id: 'update_point',
+                    geometry: {type: 'Point', coordinates: [0, 0]},
+                    properties: {}
+                }
+            ]
+        });
+    });
+});

package/src/source/geojson_worker_source.ts

@@ -0,0 +1,303 @@
+import {getJSON} from '../util/ajax';
+import {RequestPerformance} from '../util/performance';
+import rewind from '@mapbox/geojson-rewind';
+import {GeoJSONWrapper} from './geojson_wrapper';
+import vtpbf from 'vt-pbf';
+import Supercluster, {type Options as SuperclusterOptions, type ClusterProperties} from 'supercluster';
+import geojsonvt, {type Options as GeoJSONVTOptions} from 'geojson-vt';
+import {VectorTileWorkerSource} from './vector_tile_worker_source';
+import {createExpression} from '@maplibre/maplibre-gl-style-spec';
+import {isAbortError} from '../util/abort_error';
+
+import type {
+    WorkerTileParameters,
+    WorkerTileResult,
+} from '../source/worker_source';
+
+import type {LoadVectorTileResult} from './vector_tile_worker_source';
+import type {RequestParameters} from '../util/ajax';
+import {isUpdateableGeoJSON, type GeoJSONSourceDiff, applySourceDiff, toUpdateable, GeoJSONFeatureId} from './geojson_source_diff';
+import type {ClusterIDAndSource, GeoJSONWorkerSourceLoadDataResult, RemoveSourceParams} from '../util/actor_messages';
+
+/**
+ * The geojson worker options that can be passed to the worker
+ */
+export type GeoJSONWorkerOptions = {
+    source?: string;
+    cluster?: boolean;
+    geojsonVtOptions?: GeoJSONVTOptions;
+    superclusterOptions?: SuperclusterOptions<any, any>;
+    clusterProperties?: ClusterProperties;
+    filter?: Array<unknown>;
+    promoteId?: string;
+    collectResourceTiming?: boolean;
+}
+
+/**
+ * Parameters needed to load a geojson to the worker
+ */
+export type LoadGeoJSONParameters = GeoJSONWorkerOptions & {
+    type: 'geojson';
+    request?: RequestParameters;
+    /**
+     * Literal GeoJSON data. Must be provided if `request.url` is not.
+     */
+    data?: string;
+    dataDiff?: GeoJSONSourceDiff;
+};
+
+export type LoadGeoJSON = (params: LoadGeoJSONParameters, abortController: AbortController) => Promise<GeoJSON.GeoJSON>;
+
+type GeoJSONIndex = ReturnType<typeof geojsonvt> | Supercluster;
+
+/**
+ * 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).
+ */
+export class GeoJSONWorkerSource extends VectorTileWorkerSource {
+    /**
+     * The actual GeoJSON takes some time to load (as there may be a need to parse a diff, or to apply filters, or the
+     * data may even need to be loaded via a URL). This promise resolves with a ready-to-be-consumed GeoJSON which is
+     * ready to be returned by the `getData` method.
+     */
+    _pendingData: Promise<GeoJSON.GeoJSON>;
+    _pendingRequest: AbortController;
+    _geoJSONIndex: GeoJSONIndex;
+    _dataUpdateable = new Map<GeoJSONFeatureId, GeoJSON.Feature>();
+
+    override async loadVectorTile(params: WorkerTileParameters, _abortController: AbortController): Promise<LoadVectorTileResult | null> {
+        const canonical = params.tileID.canonical;
+
+        if (!this._geoJSONIndex) {
+            throw new Error('Unable to parse the data into a cluster or geojson');
+        }
+
+        const geoJSONTile = this._geoJSONIndex.getTile(canonical.z, canonical.x, canonical.y);
+        if (!geoJSONTile) {
+            return null;
+        }
+
+        const geojsonWrapper = new GeoJSONWrapper(geoJSONTile.features);
+        // Encode the geojson-vt tile into binary vector tile form.  This
+        // is a convenience that allows `FeatureIndex` to operate the same way
+        // across `VectorTileSource` and `GeoJSONSource` data.
+        let pbf = vtpbf(geojsonWrapper);
+        if (pbf.byteOffset !== 0 || pbf.byteLength !== pbf.buffer.byteLength) {
+            // Compatibility with node Buffer (https://github.com/mapbox/pbf/issues/35)
+            pbf = new Uint8Array(pbf);
+        }
+
+        return {
+            vectorTile: geojsonWrapper,
+            rawData: pbf.buffer
+        };
+    }
+
+    /**
+     * Fetches (if appropriate), parses, and index geojson data into tiles. This
+     * preparatory method must be called before {@link GeoJSONWorkerSource#loadTile}
+     * can correctly serve up tiles.
+     *
+     * Defers to {@link GeoJSONWorkerSource#loadAndProcessGeoJSON} for the pre-processing.
+     *
+     * When a `loadData` request comes in while a previous one is being processed,
+     * the previous one is aborted.
+     *
+     * @param params - the parameters
+     * @returns a promise that resolves when the data is loaded and parsed into a GeoJSON object
+     */
+    async loadData(params: LoadGeoJSONParameters): Promise<GeoJSONWorkerSourceLoadDataResult> {
+        this._pendingRequest?.abort();
+        const perf = (params && params.request && params.request.collectResourceTiming) ?
+            new RequestPerformance(params.request) : false;
+
+        this._pendingRequest = new AbortController();
+        try {
+            this._pendingData = this.loadAndProcessGeoJSON(params, this._pendingRequest);
+
+            this._geoJSONIndex = params.cluster ?
+                new Supercluster(getSuperclusterOptions(params)).load((await this._pendingData as any).features) :
+                geojsonvt(await this._pendingData, params.geojsonVtOptions);
+
+            this.loaded = {};
+
+            const result = {} as GeoJSONWorkerSourceLoadDataResult;
+            if (perf) {
+                const resourceTimingData = perf.finish();
+                // it's necessary to eval the result of getEntriesByName() here via parse/stringify
+                // late evaluation in the main thread causes TypeError: illegal invocation
+                if (resourceTimingData) {
+                    result.resourceTiming = {};
+                    result.resourceTiming[params.source] = JSON.parse(JSON.stringify(resourceTimingData));
+                }
+            }
+            return result;
+        } catch (err) {
+            delete this._pendingRequest;
+            if (isAbortError(err)) {
+                return {abandoned: true};
+            }
+            throw err;
+        }
+    }
+
+    /**
+     * Allows to get the source's actual GeoJSON.
+     *
+     * @returns a promise which is resolved with the source's actual GeoJSON
+     */
+    async getData(): Promise<GeoJSON.GeoJSON> {
+        return this._pendingData;
+    }
+
+    /**
+    * Implements {@link WorkerSource#reloadTile}.
+    *
+    * If the tile is loaded, uses the implementation in VectorTileWorkerSource.
+    * Otherwise, such as after a setData() call, we load the tile fresh.
+    *
+    * @param params - the parameters
+    * @returns A promise that resolves when the tile is reloaded
+    */
+    reloadTile(params: WorkerTileParameters): Promise<WorkerTileResult> {
+        const loaded = this.loaded,
+            uid = params.uid;
+
+        if (loaded && loaded[uid]) {
+            return super.reloadTile(params);
+        } else {
+            return this.loadTile(params);
+        }
+    }
+
+    /**
+     * Fetch, parse and process GeoJSON according to the given params.
+     *
+     * Defers to {@link GeoJSONWorkerSource#loadGeoJSON} for the fetching and parsing.
+     *
+     * @param params - the parameters
+     * @param abortController - the abort controller that allows aborting this operation
+     * @returns a promise that is resolved with the processes GeoJSON
+     */
+    async loadAndProcessGeoJSON(params: LoadGeoJSONParameters, abortController: AbortController): Promise<GeoJSON.GeoJSON> {
+        let data = await this.loadGeoJSON(params, abortController);
+
+        delete this._pendingRequest;
+        if (typeof data !== 'object') {
+            throw new Error(`Input data given to '${params.source}' is not a valid GeoJSON object.`);
+        }
+        rewind(data, true);
+
+        if (params.filter) {
+            const compiled = createExpression(params.filter, {type: 'boolean', 'property-type': 'data-driven', overridable: false, transition: false} as any);
+            if (compiled.result === 'error')
+                throw new Error(compiled.value.map(err => `${err.key}: ${err.message}`).join(', '));
+
+            const features = (data as any).features.filter(feature => compiled.value.evaluate({zoom: 0}, feature));
+            data = {type: 'FeatureCollection', features};
+        }
+
+        return data;
+    }
+
+    /**
+     * 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 - the parameters
+     * @param abortController - the abort controller that allows aborting this operation
+     * @returns a promise that resolves when the data is loaded
+     */
+    async loadGeoJSON(params: LoadGeoJSONParameters, abortController: AbortController): Promise<GeoJSON.GeoJSON> {
+        const {promoteId} = params;
+        if (params.request) {
+            const response = await getJSON<GeoJSON.GeoJSON>(params.request, abortController);
+            this._dataUpdateable = isUpdateableGeoJSON(response.data, promoteId) ? toUpdateable(response.data, promoteId) : undefined;
+            return response.data;
+        }
+        if (typeof params.data === 'string') {
+            try {
+                const parsed = JSON.parse(params.data);
+                this._dataUpdateable = isUpdateableGeoJSON(parsed, promoteId) ? toUpdateable(parsed, promoteId) : undefined;
+                return parsed;
+            } catch (e) {
+                throw new Error(`Input data given to '${params.source}' is not a valid GeoJSON object.`);
+            }
+        }
+        if (!params.dataDiff) {
+            throw new Error(`Input data given to '${params.source}' is not a valid GeoJSON object.`);
+        }
+        if (!this._dataUpdateable) {
+            throw new Error(`Cannot update existing geojson data in ${params.source}`);
+        }
+        applySourceDiff(this._dataUpdateable, params.dataDiff, promoteId);
+        return {type: 'FeatureCollection', features: Array.from(this._dataUpdateable.values())};
+    }
+
+    async removeSource(_params: RemoveSourceParams): Promise<void> {
+        if (this._pendingRequest) {
+            this._pendingRequest.abort();
+        }
+    }
+
+    getClusterExpansionZoom(params: ClusterIDAndSource): number {
+        return (this._geoJSONIndex as Supercluster).getClusterExpansionZoom(params.clusterId);
+    }
+
+    getClusterChildren(params: ClusterIDAndSource): Array<GeoJSON.Feature> {
+        return (this._geoJSONIndex as Supercluster).getChildren(params.clusterId);
+    }
+
+    getClusterLeaves(params: {
+        clusterId: number;
+        limit: number;
+        offset: number;
+    }): Array<GeoJSON.Feature> {
+        return (this._geoJSONIndex as Supercluster).getLeaves(params.clusterId, params.limit, params.offset);
+    }
+}
+
+function getSuperclusterOptions({superclusterOptions, clusterProperties}: LoadGeoJSONParameters) {
+    if (!clusterProperties || !superclusterOptions) return superclusterOptions;
+
+    const mapExpressions = {};
+    const reduceExpressions = {};
+    const globals = {accumulated: null, zoom: 0};
+    const feature = {properties: null};
+    const propertyNames = Object.keys(clusterProperties);
+
+    for (const key of propertyNames) {
+        const [operator, mapExpression] = clusterProperties[key];
+
+        const mapExpressionParsed = createExpression(mapExpression);
+        const reduceExpressionParsed = createExpression(
+            typeof operator === 'string' ? [operator, ['accumulated'], ['get', key]] : operator);
+
+        mapExpressions[key] = mapExpressionParsed.value;
+        reduceExpressions[key] = reduceExpressionParsed.value;
+    }
+
+    superclusterOptions.map = (pointProperties) => {
+        feature.properties = pointProperties;
+        const properties = {};
+        for (const key of propertyNames) {
+            properties[key] = mapExpressions[key].evaluate(globals, feature);
+        }
+        return properties;
+    };
+    superclusterOptions.reduce = (accumulated, clusterProperties) => {
+        feature.properties = clusterProperties;
+        for (const key of propertyNames) {
+            globals.accumulated = accumulated[key];
+            accumulated[key] = reduceExpressions[key].evaluate(globals, feature);
+        }
+    };
+
+    return superclusterOptions;
+}