/
index.js
277 lines (255 loc) · 10.8 KB
/
index.js
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
// @flow
import assert from 'assert';
import supported from '@mapbox/mapbox-gl-supported';
import {version} from '../package.json';
import Map from './ui/map';
import NavigationControl from './ui/control/navigation_control';
import GeolocateControl from './ui/control/geolocate_control';
import AttributionControl from './ui/control/attribution_control';
import ScaleControl from './ui/control/scale_control';
import FullscreenControl from './ui/control/fullscreen_control';
import Popup from './ui/popup';
import Marker from './ui/marker';
import Style from './style/style';
import LngLat from './geo/lng_lat';
import LngLatBounds from './geo/lng_lat_bounds';
import Point from '@mapbox/point-geometry';
import MercatorCoordinate from './geo/mercator_coordinate';
import {Evented} from './util/evented';
import config from './util/config';
import {Debug} from './util/debug';
import {isSafari} from './util/util';
import {setRTLTextPlugin, getRTLTextPluginStatus} from './source/rtl_text_plugin';
import WorkerPool from './util/worker_pool';
import {prewarm, clearPrewarmedResources} from './util/global_worker_pool';
import {clearTileCache} from './util/tile_request_cache';
import {PerformanceUtils} from './util/performance';
import type {RequestParameters, ResponseCallback} from './util/ajax';
import type {Cancelable} from './types/cancelable';
const exported = {
version,
supported,
setRTLTextPlugin,
getRTLTextPluginStatus,
Map,
NavigationControl,
GeolocateControl,
AttributionControl,
ScaleControl,
FullscreenControl,
Popup,
Marker,
Style,
LngLat,
LngLatBounds,
Point,
MercatorCoordinate,
Evented,
config,
/**
* Initializes resources like WebWorkers that can be shared across maps to lower load
* times in some situations. `maplibregl.workerUrl` and `maplibregl.workerCount`, if being
* used, must be set before `prewarm()` is called to have an effect.
*
* By default, the lifecycle of these resources is managed automatically, and they are
* lazily initialized when a Map is first created. By invoking `prewarm()`, these
* resources will be created ahead of time, and will not be cleared when the last Map
* is removed from the page. This allows them to be re-used by new Map instances that
* are created later. They can be manually cleared by calling
* `maplibregl.clearPrewarmedResources()`. This is only necessary if your web page remains
* active but stops using maps altogether.
*
* This is primarily useful when using GL-JS maps in a single page app, wherein a user
* would navigate between various views that can cause Map instances to constantly be
* created and destroyed.
*
* @function prewarm
* @example
* maplibregl.prewarm()
*/
prewarm,
/**
* Clears up resources that have previously been created by `maplibregl.prewarm()`.
* Note that this is typically not necessary. You should only call this function
* if you expect the user of your app to not return to a Map view at any point
* in your application.
*
* @function clearPrewarmedResources
* @example
* maplibregl.clearPrewarmedResources()
*/
clearPrewarmedResources,
/**
* Gets and sets the map's [access token](https://www.mapbox.com/help/define-access-token/).
*
* @var {string} accessToken
* @returns {string} The currently set access token.
* @example
* maplibregl.accessToken = myAccessToken;
* @see [Display a map](https://maplibre.org/maplibre-gl-js-docs/examples/)
*/
get accessToken(): ?string {
return config.ACCESS_TOKEN;
},
set accessToken(token: string) {
config.ACCESS_TOKEN = token;
},
/**
* Gets and sets the map's default API URL for requesting tiles, styles, sprites, and glyphs
*
* @var {string} baseApiUrl
* @returns {string} The current base API URL.
* @example
* maplibregl.baseApiUrl = 'https://api.mapbox.com';
*/
get baseApiUrl(): ?string {
return config.API_URL;
},
set baseApiUrl(url: string) {
config.API_URL = url;
},
/**
* Gets and sets the number of web workers instantiated on a page with GL JS maps.
* By default, it is set to half the number of CPU cores (capped at 6).
* Make sure to set this property before creating any map instances for it to have effect.
*
* @var {string} workerCount
* @returns {number} Number of workers currently configured.
* @example
* maplibregl.workerCount = 2;
*/
get workerCount(): number {
return WorkerPool.workerCount;
},
set workerCount(count: number) {
WorkerPool.workerCount = count;
},
/**
* Gets and sets the maximum number of images (raster tiles, sprites, icons) to load in parallel,
* which affects performance in raster-heavy maps. 16 by default.
*
* @var {string} maxParallelImageRequests
* @returns {number} Number of parallel requests currently configured.
* @example
* maplibregl.maxParallelImageRequests = 10;
*/
get maxParallelImageRequests(): number {
return config.MAX_PARALLEL_IMAGE_REQUESTS;
},
set maxParallelImageRequests(numRequests: number) {
config.MAX_PARALLEL_IMAGE_REQUESTS = numRequests;
},
/**
* Clears browser storage used by this library. Using this method flushes the Mapbox tile
* cache that is managed by this library. Tiles may still be cached by the browser
* in some cases.
*
* This API is supported on browsers where the [`Cache` API](https://developer.mozilla.org/en-US/docs/Web/API/Cache)
* is supported and enabled. This includes all major browsers when pages are served over
* `https://`, except Internet Explorer and Edge Mobile.
*
* When called in unsupported browsers or environments (private or incognito mode), the
* callback will be called with an error argument.
*
* @function clearStorage
* @param {Function} callback Called with an error argument if there is an error.
* @example
* maplibregl.clearStorage();
*/
clearStorage(callback?: (err: ?Error) => void) {
clearTileCache(callback);
},
workerUrl: '',
/**
* Sets a custom load tile function that will be called when using a source that starts with a custom url schema.
* The example below will be triggered for custom:// urls defined in the sources list in the style definitions.
* The function passed will receive the request parameters and should call the callback with the resulting request,
* for example a pbf vector tile, non-compressed, represented as ArrayBuffer.
* @param {string} customProtocol - the protocol to hook, for example 'custom'
* @param {Function} loadFn - the function to use when trying to fetch a tile specified by the customProtocol
* @example
* // this will fetch a file using the fetch API (this is obviously a non iteresting example...)
* maplibre.addProtocol('custom', (params, callback) => {
fetch(`https://${params.url.split("://")[1]}`)
.then(t => {
if (t.status == 200) {
t.arrayBuffer().then(arr => {
callback(null, arr, null, null);
});
} else {
callback(new Error(`Tile fetch error: ${t.statusText}`));
}
})
.catch(e => {
callback(new Error(e));
});
return { cancel: () => { } };
});
* // the following is an example of a way to return an error when trying to load a tile
* maplibre.addProtocol('custom2', (params, callback) => {
* callback(new Error('someErrorMessage'));
* return { cancel: () => { } };
* });
*/
addProtocol(customProtocol: string, loadFn: (requestParameters: RequestParameters, callback: ResponseCallback<any>) => Cancelable) {
config.REGISTERED_PROTOCOLS[customProtocol] = loadFn;
},
/**
* Removes a previusly added protocol
* @param {string} customProtocol - the custom protocol to remove registration for
* @example
* maplibregl.removeProtocol('custom');
*/
removeProtocol(customProtocol: string) {
delete config.REGISTERED_PROTOCOLS[customProtocol];
}
};
//This gets automatically stripped out in production builds.
Debug.extend(exported, {isSafari, getPerformanceMetrics: PerformanceUtils.getPerformanceMetrics});
/**
* The version of Mapbox GL JS in use as specified in `package.json`,
* `CHANGELOG.md`, and the GitHub release.
*
* @var {string} version
*/
/**
* Test whether the browser [supports Mapbox GL JS](https://www.mapbox.com/help/mapbox-browser-support/#mapbox-gl-js).
*
* @function supported
* @param {Object} [options]
* @param {boolean} [options.failIfMajorPerformanceCaveat=false] If `true`,
* the function will return `false` if the performance of Mapbox GL JS would
* be dramatically worse than expected (e.g. a software WebGL renderer would be used).
* @return {boolean}
* @example
* // Show an alert if the browser does not support Mapbox GL
* if (!maplibregl.supported()) {
* alert('Your browser does not support Mapbox GL');
* }
* @see [Check for browser support](https://maplibre.org/maplibre-gl-js-docs/example/check-for-support/)
*/
/**
* Sets the map's [RTL text plugin](https://www.mapbox.com/mapbox-gl-js/plugins/#mapbox-gl-rtl-text).
* Necessary for supporting the Arabic and Hebrew languages, which are written right-to-left. Mapbox Studio loads this plugin by default.
*
* @function setRTLTextPlugin
* @param {string} pluginURL URL pointing to the Mapbox RTL text plugin source.
* @param {Function} callback Called with an error argument if there is an error.
* @param {boolean} lazy If set to `true`, mapboxgl will defer loading the plugin until rtl text is encountered,
* rtl text will then be rendered only after the plugin finishes loading.
* @example
* maplibregl.setRTLTextPlugin('https://api.mapbox.com/mapbox-gl-js/plugins/mapbox-gl-rtl-text/v0.2.0/mapbox-gl-rtl-text.js');
* @see [Add support for right-to-left scripts](https://maplibre.org/maplibre-gl-js-docs/example/mapbox-gl-rtl-text/)
*/
/**
* Gets the map's [RTL text plugin](https://www.mapbox.com/mapbox-gl-js/plugins/#mapbox-gl-rtl-text) status.
* The status can be `unavailable` (i.e. not requested or removed), `loading`, `loaded` or `error`.
* If the status is `loaded` and the plugin is requested again, an error will be thrown.
*
* @function getRTLTextPluginStatus
* @example
* const pluginStatus = maplibregl.getRTLTextPluginStatus();
*/
export default exported;
// canary assert: used to confirm that asserts have been removed from production build
assert(true, 'canary assert');