maplibre-gl 2.0.1 → 2.0.5

package/src/source/source_cache.test.ts

@@ -1,10 +1,10 @@
 import SourceCache from './source_cache';
-import {setType} from './source';
+import {setSourceType} from './source';
 import Tile from './tile';
 import {OverscaledTileID} from './tile_id';
 import Transform from '../geo/transform';
 import LngLat from '../geo/lng_lat';
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 import {Event, ErrorEvent, Evented} from '../util/evented';
 import {extend} from '../util/util';
 import browser from '../util/browser';
@@ -63,7 +63,7 @@ function createSource(id: string, sourceOptions: any, _dispatcher: any, eventedP
     return source;
 }
 
-setType('mock-source-type', createSource as any);
+setSourceType('mock-source-type', createSource as any);
 
 function createSourceCache(options?, used?) {
     const sc = new SourceCache('id', extend({

package/src/source/source_cache.ts

@@ -7,7 +7,7 @@ import MercatorCoordinate from '../geo/mercator_coordinate';
 import {keysDifference} from '../util/util';
 import EXTENT from '../data/extent';
 import Context from '../gl/context';
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 import browser from '../util/browser';
 import {OverscaledTileID} from './tile_id';
 import assert from 'assert';

package/src/source/tile.ts

@@ -30,7 +30,7 @@ import type Transform from '../geo/transform';
 import type {LayerFeatureStates} from './source_state';
 import type {Cancelable} from '../types/cancelable';
 import type {FilterSpecification} from '../style-spec/types';
-import type Point from '../util/point';
+import type Point from '@mapbox/point-geometry';
 import {mat4} from 'gl-matrix';
 import type {VectorTileLayer} from '@mapbox/vector-tile';
 

package/src/source/tile_id.ts

@@ -1,6 +1,6 @@
 import {getTileBBox} from '@mapbox/whoots-js';
 import EXTENT from '../data/extent';
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../geo/mercator_coordinate';
 
 import assert from 'assert';

package/src/source/vector_tile_worker_source.test.ts

@@ -0,0 +1,306 @@
+import fs from 'fs';
+import path from 'path';
+import vt from '@mapbox/vector-tile';
+import Protobuf from 'pbf';
+import VectorTileWorkerSource from '../source/vector_tile_worker_source';
+import StyleLayerIndex from '../style/style_layer_index';
+import {fakeServer, SinonFakeServer} from 'sinon';
+import Actor from '../util/actor';
+import {TileParameters, WorkerTileParameters} from './worker_source';
+import WorkerTile from './worker_tile';
+import {setPerformance} from '../util/test/util';
+
+describe('vector tile worker source', () => {
+    const actor = {send: () => {}} as any as Actor;
+    let server: SinonFakeServer;
+    let originalGetEntriesByName;
+    let originalMeasure;
+    let originalMark;
+
+    beforeEach(() => {
+        global.fetch = null;
+        server = fakeServer.create();
+        setPerformance();
+        originalGetEntriesByName = window.performance.getEntriesByName;
+        originalMeasure = window.performance.measure;
+        originalMark = window.performance.mark;
+
+    });
+
+    afterEach(() => {
+        server.restore();
+        jest.clearAllMocks();
+        window.performance.getEntriesByName = originalGetEntriesByName;
+        window.performance.measure = originalMeasure;
+        window.performance.mark = originalMark;
+    });
+    test('VectorTileWorkerSource#abortTile aborts pending request', () => {
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+
+        source.loadTile({
+            source: 'source',
+            uid: 0,
+            tileID: {overscaledZ: 0, wrap: 0, canonical: {x: 0, y: 0, z: 0, w: 0}},
+            request: {url: 'http://localhost:2900/abort'}
+        } as any as WorkerTileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res).toBeFalsy();
+        });
+
+        source.abortTile({
+            source: 'source',
+            uid: 0
+        } as any as TileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res).toBeFalsy();
+        });
+
+        expect(source.loading).toEqual({});
+    });
+
+    test('VectorTileWorkerSource#removeTile removes loaded tile', () => {
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+
+        source.loaded = {
+            '0': {} as WorkerTile
+        };
+
+        source.removeTile({
+            source: 'source',
+            uid: 0
+        } as any as TileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res).toBeFalsy();
+        });
+
+        expect(source.loaded).toEqual({});
+    });
+
+    test('VectorTileWorkerSource#reloadTile reloads a previously-loaded tile', () => {
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+        const parse = jest.fn();
+
+        source.loaded = {
+            '0': {
+                status: 'done',
+                vectorTile: {},
+                parse
+            } as any as WorkerTile
+        };
+
+        const callback = jest.fn();
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback);
+        expect(parse).toHaveBeenCalledTimes(1);
+
+        parse.mock.calls[0][4]();
+        expect(callback).toHaveBeenCalledTimes(1);
+    });
+
+    test('VectorTileWorkerSource#reloadTile queues a reload when parsing is in progress', () => {
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+        const parse = jest.fn();
+
+        source.loaded = {
+            '0': {
+                status: 'done',
+                vectorTile: {},
+                parse
+            } as any as WorkerTile
+        };
+
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback1);
+        expect(parse).toHaveBeenCalledTimes(1);
+
+        source.loaded[0].status = 'parsing';
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback2);
+        expect(parse).toHaveBeenCalledTimes(1);
+
+        parse.mock.calls[0][4]();
+        expect(parse).toHaveBeenCalledTimes(2);
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(0);
+
+        parse.mock.calls[1][4]();
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+    });
+
+    test('VectorTileWorkerSource#reloadTile handles multiple pending reloads', () => {
+        // https://github.com/mapbox/mapbox-gl-js/issues/6308
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+        const parse = jest.fn();
+
+        source.loaded = {
+            '0': {
+                status: 'done',
+                vectorTile: {},
+                parse
+            } as any as WorkerTile
+        };
+
+        const callback1 = jest.fn();
+        const callback2 = jest.fn();
+        const callback3 = jest.fn();
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback1);
+        expect(parse).toHaveBeenCalledTimes(1);
+
+        source.loaded[0].status = 'parsing';
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback2);
+        expect(parse).toHaveBeenCalledTimes(1);
+
+        parse.mock.calls[0][4]();
+        expect(parse).toHaveBeenCalledTimes(2);
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(0);
+        expect(callback3).toHaveBeenCalledTimes(0);
+
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback3);
+        expect(parse).toHaveBeenCalledTimes(2);
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(0);
+        expect(callback3).toHaveBeenCalledTimes(0);
+
+        parse.mock.calls[1][4]();
+        expect(parse).toHaveBeenCalledTimes(3);
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+        expect(callback3).toHaveBeenCalledTimes(0);
+
+        parse.mock.calls[2][4]();
+        expect(callback1).toHaveBeenCalledTimes(1);
+        expect(callback2).toHaveBeenCalledTimes(1);
+        expect(callback3).toHaveBeenCalledTimes(1);
+
+    });
+
+    test('VectorTileWorkerSource#reloadTile does not reparse tiles with no vectorTile data but does call callback', () => {
+        const source = new VectorTileWorkerSource(actor, new StyleLayerIndex(), []);
+        const parse = jest.fn();
+
+        source.loaded = {
+            '0': {
+                status: 'done',
+                parse
+            } as any as WorkerTile
+        };
+
+        const callback = jest.fn();
+
+        source.reloadTile({uid: 0} as any as WorkerTileParameters, callback);
+        expect(parse).not.toHaveBeenCalled();
+        expect(callback).toHaveBeenCalledTimes(1);
+
+    });
+
+    test('VectorTileWorkerSource provides resource timing information', done => {
+        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/fixtures/mbsv5-6-18-23.vector.pbf'));
+
+        function loadVectorData(params, callback) {
+            return callback(null, {
+                vectorTile: new vt.VectorTile(new Protobuf(rawTileData)),
+                rawData: rawTileData,
+                cacheControl: null,
+                expires: null
+            });
+        }
+
+        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/faketile.pbf',
+            nextHopProtocol: 'http/1.1',
+            redirectEnd: 0,
+            redirectStart: 0,
+            requestStart: 477,
+            responseEnd: 815,
+            responseStart: 672,
+            secureConnectionStart: 0
+        };
+
+        const layerIndex = new StyleLayerIndex([{
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'fill'
+        }]);
+
+        const source = new VectorTileWorkerSource(actor, layerIndex, [], loadVectorData);
+
+        window.performance.getEntriesByName = jest.fn().mockReturnValue([ exampleResourceTiming ]);
+
+        source.loadTile({
+            source: 'source',
+            uid: 0,
+            tileID: {overscaledZ: 0, wrap: 0, canonical: {x: 0, y: 0, z: 0, w: 0}},
+            request: {url: 'http://localhost:2900/faketile.pbf', collectResourceTiming: true}
+        } as any as WorkerTileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res.resourceTiming[0]).toEqual(exampleResourceTiming);
+            done();
+        });
+    });
+
+    test('VectorTileWorkerSource provides resource timing information (fallback method)', done => {
+        const rawTileData = fs.readFileSync(path.join(__dirname, '/../../test/fixtures/mbsv5-6-18-23.vector.pbf'));
+
+        function loadVectorData(params, callback) {
+            return callback(null, {
+                vectorTile: new vt.VectorTile(new Protobuf(rawTileData)),
+                rawData: rawTileData,
+                cacheControl: null,
+                expires: null
+            });
+        }
+
+        const layerIndex = new StyleLayerIndex([{
+            id: 'test',
+            source: 'source',
+            'source-layer': 'test',
+            type: 'fill'
+        }]);
+
+        const source = new VectorTileWorkerSource(actor, layerIndex, [], loadVectorData);
+
+        const sampleMarks = [100, 350];
+        const marks = {};
+        const measures = {};
+        window.performance.getEntriesByName = jest.fn().mockImplementation(name => (measures[name] || []));
+        window.performance.mark = jest.fn().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;
+        });
+
+        source.loadTile({
+            source: 'source',
+            uid: 0,
+            tileID: {overscaledZ: 0, wrap: 0, canonical: {x: 0, y: 0, z: 0, w: 0}},
+            request: {url: 'http://localhost:2900/faketile.pbf', collectResourceTiming: true}
+        } as any as WorkerTileParameters, (err, res) => {
+            expect(err).toBeFalsy();
+            expect(res.resourceTiming[0]).toEqual(
+                {'duration': 250, 'entryType': 'measure', 'name': 'http://localhost:2900/faketile.pbf', 'startTime': 100}
+            );
+            done();
+        });
+    });
+});

package/src/source/worker_tile.test.ts

@@ -4,6 +4,7 @@ import {OverscaledTileID} from '../source/tile_id';
 import StyleLayerIndex from '../style/style_layer_index';
 import {WorkerTileParameters} from './worker_source';
 import Actor from '../util/actor';
+import {VectorTile} from '@mapbox/vector-tile';
 
 function createWorkerTile() {
     return new WorkerTile({
@@ -87,7 +88,7 @@ describe('worker tile', () => {
                     version: 1
                 }
             }
-        };
+        } as any as VectorTile;
 
         const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
 

package/src/style/query_utils.ts

@@ -1,4 +1,4 @@
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 
 import type {PossiblyEvaluatedPropertyValue} from './properties';
 import type StyleLayer from '../style/style_layer';

package/src/style/style.ts

@@ -13,7 +13,7 @@ import {getJSON, getReferrer, makeRequest, ResourceType} from '../util/ajax';
 import browser from '../util/browser';
 import Dispatcher from '../util/dispatcher';
 import {validateStyle, emitValidationErrors as _emitValidationErrors} from './validate_style';
-import {getType as getSourceType, setType as setSourceType, Source} from '../source/source';
+import {getSourceType, setSourceType, Source} from '../source/source';
 import type {SourceClass} from '../source/source';
 import {queryRenderedFeatures, queryRenderedSymbols, querySourceFeatures} from '../source/query_features';
 import SourceCache from '../source/source_cache';

package/src/style/style_layer/circle_style_layer.ts

@@ -6,7 +6,7 @@ import {getMaximumPaintValue, translateDistance, translate} from '../query_utils
 import properties, {CircleLayoutPropsPossiblyEvaluated, CirclePaintPropsPossiblyEvaluated} from './circle_style_layer_properties';
 import {Transitionable, Transitioning, Layout, PossiblyEvaluated} from '../properties';
 import {mat4, vec4} from 'gl-matrix';
-import Point from '../../util/point';
+import Point from '@mapbox/point-geometry';
 import type {FeatureState} from '../../style-spec/expression';
 import type Transform from '../../geo/transform';
 import type {Bucket, BucketParameters} from '../../data/bucket';

package/src/style/style_layer/fill_extrusion_style_layer.ts

@@ -6,7 +6,7 @@ import {translateDistance, translate} from '../query_utils';
 import properties, {FillExtrusionPaintPropsPossiblyEvaluated} from './fill_extrusion_style_layer_properties';
 import {Transitionable, Transitioning, PossiblyEvaluated} from '../properties';
 import {mat4, vec4} from 'gl-matrix';
-import Point from '../../util/point';
+import Point from '@mapbox/point-geometry';
 import type {FeatureState} from '../../style-spec/expression';
 import type {BucketParameters} from '../../data/bucket';
 import type {FillExtrusionPaintProps} from './fill_extrusion_style_layer_properties';

package/src/style/style_layer/fill_style_layer.ts

@@ -8,7 +8,7 @@ import {Transitionable, Transitioning, Layout, PossiblyEvaluated} from '../prope
 
 import type {FeatureState} from '../../style-spec/expression';
 import type {BucketParameters} from '../../data/bucket';
-import type Point from '../../util/point';
+import type Point from '@mapbox/point-geometry';
 import type {FillLayoutProps, FillPaintProps} from './fill_style_layer_properties';
 import type EvaluationParameters from '../evaluation_parameters';
 import type Transform from '../../geo/transform';

package/src/style/style_layer/line_style_layer.ts

@@ -1,4 +1,4 @@
-import Point from '../../util/point';
+import Point from '@mapbox/point-geometry';
 
 import StyleLayer from '../style_layer';
 import LineBucket from '../../data/bucket/line_bucket';

package/src/style/style_layer.ts

@@ -13,7 +13,7 @@ import {supportsPropertyExpression} from '../style-spec/util/properties';
 
 import type {FeatureState} from '../style-spec/expression';
 import type {Bucket} from '../data/bucket';
-import type Point from '../util/point';
+import type Point from '@mapbox/point-geometry';
 import type {FeatureFilter} from '../style-spec/feature_filter';
 import type {TransitionParameters, PropertyValue} from './properties';
 import EvaluationParameters from './evaluation_parameters';
@@ -32,21 +32,6 @@ import type {VectorTileFeature} from '@mapbox/vector-tile';
 
 const TRANSITION_SUFFIX = '-transition';
 
-// this interface is used to allow optional overload for this methods in the derived classes.
-interface StyleLayer {
-    queryRadius?(bucket: Bucket): number;
-    queryIntersectsFeature?(
-      queryGeometry: Array<Point>,
-      feature: VectorTileFeature,
-      featureState: FeatureState,
-      geometry: Array<Array<Point>>,
-      zoom: number,
-      transform: Transform,
-      pixelsToTileUnits: number,
-      pixelPosMatrix: mat4
-    ): boolean | number;
-}
-
 abstract class StyleLayer extends Evented {
     id: string;
     metadata: unknown;
@@ -71,6 +56,18 @@ abstract class StyleLayer extends Evented {
     readonly onAdd: ((map: Map) => void);
     readonly onRemove: ((map: Map) => void);
 
+    queryRadius?(bucket: Bucket): number;
+    queryIntersectsFeature?(
+      queryGeometry: Array<Point>,
+      feature: VectorTileFeature,
+      featureState: FeatureState,
+      geometry: Array<Array<Point>>,
+      zoom: number,
+      transform: Transform,
+      pixelsToTileUnits: number,
+      pixelPosMatrix: mat4
+    ): boolean | number;
+
     constructor(layer: LayerSpecification | CustomLayerInterface, properties: Readonly<{
       layout?: Properties<any>;
       paint?: Properties<any>;

package/src/style-spec/expression/index.ts

@@ -23,7 +23,7 @@ import type {Result} from '../util/result';
 import type {InterpolationType} from './definitions/interpolate';
 import type {PropertyValueSpecification} from '../types';
 import type {FormattedSection} from './types/formatted';
-import type Point from '../../util/point';
+import type Point from '@mapbox/point-geometry';
 import type {CanonicalTileID} from '../../source/tile_id';
 
 export type Feature = {

package/src/style-spec/feature_filter/feature_filter.test.ts

@@ -1,7 +1,7 @@
 import {default as createFilter, isExpressionFilter} from '.';
 
 import convertFilter from './convert';
-import Point from '../../util/point';
+import Point from '@mapbox/point-geometry';
 import MercatorCoordinate from '../../geo/mercator_coordinate';
 import EXTENT from '../../data/extent';
 import {CanonicalTileID} from '../../source/tile_id';

package/src/style-spec/migrate.test.ts

@@ -0,0 +1,112 @@
+import migrate from './migrate';
+import * as spec from './style-spec';
+import v8 from './reference/v8.json';
+import validate from './validate_style';
+
+describe('migrate', () => {
+    test('does not migrate from version 5', () => {
+        expect(() => {
+            migrate({version: 5, layers: []});
+        }).toThrow(new Error('Cannot migrate from 5'));
+    });
+
+    test('does not migrate from version 6', () => {
+        expect(() => {
+            migrate({version: 6, layers: []});
+        }).toThrow(new Error('Cannot migrate from 6'));
+    });
+
+    test('migrates to latest version from version 7', () => {
+        expect(migrate({version: 7, layers: []}).version).toEqual(spec.latest.$version);
+    });
+
+    test('converts token strings to expressions', () => {
+        const migrated = migrate({
+            version: 8,
+            layers: [{
+                id: '1',
+                type: 'symbol',
+                layout: {'text-field': 'a{x}', 'icon-image': '{y}'}
+            }]
+        });
+        expect(migrated.layers[0].layout['text-field']).toEqual(['concat', 'a', ['get', 'x']]);
+        expect(migrated.layers[0].layout['icon-image']).toEqual(['to-string', ['get', 'y']]);
+    });
+
+    test('converts stop functions to expressions', () => {
+        const migrated = migrate({
+            version: 8,
+            layers: [{
+                id: '1',
+                type: 'background',
+                paint: {
+                    'background-opacity': {
+                        base: 1.0,
+                        stops: [[0, 1], [10, 0.72]]
+                    }
+                }
+            }, {
+                id: '2',
+                type: 'background',
+                paint: {
+                    'background-opacity': {
+                        base: 1.0,
+                        stops: [[0, [1, 2]], [10, [0.72, 0.98]]]
+                    }
+                }
+            }]
+        });
+        expect(migrated.layers[0].paint['background-opacity']).toEqual([
+            'interpolate',
+            ['linear'],
+            ['zoom'],
+            0,
+            1,
+            10,
+            0.72
+        ]);
+        expect(migrated.layers[1].paint['background-opacity']).toEqual([
+            'interpolate',
+            ['linear'],
+            ['zoom'],
+            0,
+            ['literal', [1, 2]],
+            10,
+            ['literal', [0.72, 0.98]]
+        ]);
+    });
+
+    test('converts categorical function on resolvedImage type to valid expression', () => {
+        const migrated = migrate({
+            version: 8,
+            sources: {
+                streets: {
+                    url: 'mapbox://mapbox.streets',
+                    type: 'vector'
+                }
+            },
+            layers: [{
+                id: '1',
+                source: 'streets',
+                'source-layer': 'labels',
+                type: 'symbol',
+                layout: {
+                    'icon-image': {
+                        base: 1,
+                        type: 'categorical',
+                        property: 'type',
+                        stops: [['park', 'some-icon']]
+                    }
+                }
+            }]
+        });
+        expect(migrated.layers[0].layout['icon-image']).toEqual([
+            'match',
+            ['get', 'type' ],
+            'park',
+            'some-icon',
+            ''
+        ]);
+        expect(validate(migrated, v8)).toEqual([]);
+    });
+});

package/src/style-spec/style-spec.ts

@@ -115,6 +115,3 @@ export {
     validate,
     visit
 };
-
-(validate as any).parsed = validate;
-(validate as any).latest = validate;

package/src/style-spec/validate_spec.test.ts

@@ -0,0 +1,29 @@
+import glob from 'glob';
+import fs from 'fs';
+import path from 'path';
+import validate from '../style-spec/validate_style';
+import reference from './reference/latest';
+
+const UPDATE = !!process.env.UPDATE;
+
+describe('validate_spec', () => {
+    glob.sync('test/unit/style-spec/fixture/*.input.json').forEach((file) => {
+        test(path.basename(file), () => {
+            const outputfile = file.replace('.input', '.output');
+            const style = fs.readFileSync(file);
+            const result = validate(style);
+            if (UPDATE) fs.writeFileSync(outputfile, JSON.stringify(result, null, 2));
+            const expectedOutput = JSON.parse(fs.readFileSync(outputfile).toString());
+            expect(result).toEqual(expectedOutput);
+        });
+    });
+
+    test('errors from validate do not contain line numbers', () => {
+        const fixtures = glob.sync('test/unit/style-spec/fixture/*.input.json');
+        const style = JSON.parse(fs.readFileSync(fixtures[0]).toString());
+
+        const result = validate(style, reference);
+        expect(result[0].line).toBeUndefined();
+    });
+
+});

package/src/symbol/anchor.ts

@@ -1,4 +1,4 @@
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 
 import {register} from '../util/web_worker_transfer';
 

package/src/symbol/check_max_angle.test.ts

@@ -1,4 +1,4 @@
-import Point from '../util/point';
+import Point from '@mapbox/point-geometry';
 import checkMaxAngle from './check_max_angle';
 import Anchor from './anchor';
 

package/src/symbol/check_max_angle.ts

@@ -1,6 +1,6 @@
 export default checkMaxAngle;
 
-import type Point from '../util/point';
+import type Point from '@mapbox/point-geometry';
 import type Anchor from './anchor';
 
 /**