mapbox-gl 1.13.2

package/src/util/vectortile_to_geojson.js

@@ -0,0 +1,50 @@
+// @flow
+import type {GeoJSONGeometry} from '@mapbox/geojson-types';
+
+class Feature {
+    type: 'Feature';
+    _geometry: ?GeoJSONGeometry;
+    properties: {};
+    id: number | string | void;
+
+    _vectorTileFeature: VectorTileFeature;
+
+    constructor(vectorTileFeature: VectorTileFeature, z: number, x: number, y: number, id: string | number | void) {
+        this.type = 'Feature';
+
+        this._vectorTileFeature = vectorTileFeature;
+        (vectorTileFeature: any)._z = z;
+        (vectorTileFeature: any)._x = x;
+        (vectorTileFeature: any)._y = y;
+
+        this.properties = vectorTileFeature.properties;
+        this.id = id;
+    }
+
+    get geometry(): ?GeoJSONGeometry {
+        if (this._geometry === undefined) {
+            this._geometry = this._vectorTileFeature.toGeoJSON(
+                (this._vectorTileFeature: any)._x,
+                (this._vectorTileFeature: any)._y,
+                (this._vectorTileFeature: any)._z).geometry;
+        }
+        return this._geometry;
+    }
+
+    set geometry(g: ?GeoJSONGeometry) {
+        this._geometry = g;
+    }
+
+    toJSON() {
+        const json = {
+            geometry: this.geometry
+        };
+        for (const i in this) {
+            if (i === '_geometry' || i === '_vectorTileFeature') continue;
+            json[i] = (this: any)[i];
+        }
+        return json;
+    }
+}
+
+export default Feature;

package/src/util/verticalize_punctuation.js

@@ -0,0 +1,114 @@
+// @flow
+
+import {
+    charHasRotatedVerticalOrientation,
+} from './script_detection';
+
+export const verticalizedCharacterMap = {
+    '!': '︕',
+    '#': '＃',
+    '$': '＄',
+    '%': '％',
+    '&': '＆',
+    '(': '︵',
+    ')': '︶',
+    '*': '＊',
+    '+': '＋',
+    ',': '︐',
+    '-': '︲',
+    '.': '・',
+    '/': '／',
+    ':': '︓',
+    ';': '︔',
+    '<': '︿',
+    '=': '＝',
+    '>': '﹀',
+    '?': '︖',
+    '@': '＠',
+    '[': '﹇',
+    '\\': '＼',
+    ']': '﹈',
+    '^': '＾',
+    '_': '︳',
+    '`': '｀',
+    '{': '︷',
+    '|': '―',
+    '}': '︸',
+    '~': '～',
+    '¢': '￠',
+    '£': '￡',
+    '¥': '￥',
+    '¦': '￤',
+    '¬': '￢',
+    '¯': '￣',
+    '–': '︲',
+    '—': '︱',
+    '‘': '﹃',
+    '’': '﹄',
+    '“': '﹁',
+    '”': '﹂',
+    '…': '︙',
+    '‧': '・',
+    '₩': '￦',
+    '、': '︑',
+    '。': '︒',
+    '〈': '︿',
+    '〉': '﹀',
+    '《': '︽',
+    '》': '︾',
+    '「': '﹁',
+    '」': '﹂',
+    '『': '﹃',
+    '』': '﹄',
+    '【': '︻',
+    '】': '︼',
+    '〔': '︹',
+    '〕': '︺',
+    '〖': '︗',
+    '〗': '︘',
+    '！': '︕',
+    '（': '︵',
+    '）': '︶',
+    '，': '︐',
+    '－': '︲',
+    '．': '・',
+    '：': '︓',
+    '；': '︔',
+    '＜': '︿',
+    '＞': '﹀',
+    '？': '︖',
+    '［': '﹇',
+    '］': '﹈',
+    '＿': '︳',
+    '｛': '︷',
+    '｜': '―',
+    '｝': '︸',
+    '｟': '︵',
+    '｠': '︶',
+    '｡': '︒',
+    '｢': '﹁',
+    '｣': '﹂'
+};
+
+export default function verticalizePunctuation(input: string) {
+    let output = '';
+
+    for (let i = 0; i < input.length; i++) {
+        const nextCharCode = input.charCodeAt(i + 1) || null;
+        const prevCharCode = input.charCodeAt(i - 1) || null;
+
+        const canReplacePunctuation = (
+            (!nextCharCode || !charHasRotatedVerticalOrientation(nextCharCode) || verticalizedCharacterMap[input[i + 1]]) &&
+            (!prevCharCode || !charHasRotatedVerticalOrientation(prevCharCode) || verticalizedCharacterMap[input[i - 1]])
+        );
+
+        if (canReplacePunctuation && verticalizedCharacterMap[input[i]]) {
+            output += verticalizedCharacterMap[input[i]];
+        } else {
+            output += input[i];
+        }
+    }
+
+    return output;
+}
+

package/src/util/web_worker.js

@@ -0,0 +1,91 @@
+// @flow
+
+// This file is intended for use in the GL-JS test suite
+// It implements a MessageBus main thread interface for use in Node environments
+// In a browser environment, this file is replaced with ./src/util/browser/web_worker.js
+// when Rollup builds the main bundle.
+// See package.json#browser
+
+import Worker from '../source/worker';
+
+import type {WorkerSource} from '../source/worker_source';
+
+type MessageListener = ({data: Object}) => mixed;
+
+// The main thread interface. Provided by Worker in a browser environment,
+// and MessageBus below in a node environment.
+export interface WorkerInterface {
+    addEventListener(type: 'message', listener: MessageListener): void;
+    removeEventListener(type: 'message', listener: MessageListener): void;
+    postMessage(message: any): void;
+    terminate(): void;
+}
+
+export interface WorkerGlobalScopeInterface {
+    importScripts(...urls: Array<string>): void;
+
+    registerWorkerSource: (string, Class<WorkerSource>) => void,
+    registerRTLTextPlugin: (_: any) => void
+}
+
+class MessageBus implements WorkerInterface, WorkerGlobalScopeInterface {
+    addListeners: Array<MessageListener>;
+    postListeners: Array<MessageListener>;
+    target: MessageBus;
+    registerWorkerSource: *;
+    registerRTLTextPlugin: *;
+
+    constructor(addListeners: Array<MessageListener>, postListeners: Array<MessageListener>) {
+        this.addListeners = addListeners;
+        this.postListeners = postListeners;
+    }
+
+    addEventListener(event: 'message', callback: MessageListener) {
+        if (event === 'message') {
+            this.addListeners.push(callback);
+        }
+    }
+
+    removeEventListener(event: 'message', callback: MessageListener) {
+        const i = this.addListeners.indexOf(callback);
+        if (i >= 0) {
+            this.addListeners.splice(i, 1);
+        }
+    }
+
+    postMessage(data: Object) {
+        setImmediate(() => {
+            try {
+                for (const listener of this.postListeners) {
+                    listener({data, target: this.target});
+                }
+            } catch (e) {
+                console.error(e);
+            }
+        });
+    }
+
+    terminate() {
+        this.addListeners.splice(0, this.addListeners.length);
+        this.postListeners.splice(0, this.postListeners.length);
+    }
+
+    importScripts() {}
+}
+
+export default function WebWorker(): WorkerInterface {
+    const parentListeners = [],
+        workerListeners = [],
+        parentBus = new MessageBus(workerListeners, parentListeners),
+        workerBus = new MessageBus(parentListeners, workerListeners);
+
+    parentBus.target = workerBus;
+    workerBus.target = parentBus;
+
+    new WebWorker.Worker(workerBus);
+
+    return parentBus;
+}
+
+// expose to allow stubbing in unit tests
+WebWorker.Worker = Worker;

package/src/util/web_worker_transfer.js

@@ -0,0 +1,266 @@
+// @flow
+
+import assert from 'assert';
+
+import Grid from 'grid-index';
+import Color from '../style-spec/util/color';
+import {StylePropertyFunction, StyleExpression, ZoomDependentExpression, ZoomConstantExpression} from '../style-spec/expression';
+import CompoundExpression from '../style-spec/expression/compound_expression';
+import expressions from '../style-spec/expression/definitions';
+import ResolvedImage from '../style-spec/expression/types/resolved_image';
+import window from './window';
+const {ImageData, ImageBitmap} = window;
+
+import type {Transferable} from '../types/transferable';
+
+type SerializedObject = {[_: string]: Serialized }; // eslint-disable-line
+export type Serialized =
+    | null
+    | void
+    | boolean
+    | number
+    | string
+    | Boolean
+    | Number
+    | String
+    | Date
+    | RegExp
+    | ArrayBuffer
+    | $ArrayBufferView
+    | ImageData
+    | Array<Serialized>
+    | SerializedObject;
+
+type Registry = {
+    [_: string]: {
+        klass: Class<any>,
+        omit: $ReadOnlyArray<string>,
+        shallow: $ReadOnlyArray<string>
+    }
+};
+
+type RegisterOptions<T> = {
+    omit?: $ReadOnlyArray<$Keys<T>>,
+    shallow?: $ReadOnlyArray<$Keys<T>>
+}
+
+const registry: Registry = {};
+
+/**
+ * Register the given class as serializable.
+ *
+ * @param options
+ * @param options.omit List of properties to omit from serialization (e.g., cached/computed properties)
+ * @param options.shallow List of properties that should be serialized by a simple shallow copy, rather than by a recursive call to serialize().
+ *
+ * @private
+ */
+export function register<T: any>(name: string, klass: Class<T>, options: RegisterOptions<T> = {}) {
+    assert(!registry[name], `${name} is already registered.`);
+    (Object.defineProperty: any)(klass, '_classRegistryKey', {
+        value: name,
+        writeable: false
+    });
+    registry[name] = {
+        klass,
+        omit: options.omit || [],
+        shallow: options.shallow || []
+    };
+}
+
+register('Object', Object);
+
+type SerializedGrid = { buffer: ArrayBuffer };
+
+Grid.serialize = function serialize(grid: Grid, transferables?: Array<Transferable>): SerializedGrid {
+    const buffer = grid.toArrayBuffer();
+    if (transferables) {
+        transferables.push(buffer);
+    }
+    return {buffer};
+};
+
+Grid.deserialize = function deserialize(serialized: SerializedGrid): Grid {
+    return new Grid(serialized.buffer);
+};
+register('Grid', Grid);
+
+register('Color', Color);
+register('Error', Error);
+register('ResolvedImage', ResolvedImage);
+
+register('StylePropertyFunction', StylePropertyFunction);
+register('StyleExpression', StyleExpression, {omit: ['_evaluator']});
+
+register('ZoomDependentExpression', ZoomDependentExpression);
+register('ZoomConstantExpression', ZoomConstantExpression);
+register('CompoundExpression', CompoundExpression, {omit: ['_evaluate']});
+for (const name in expressions) {
+    if ((expressions[name]: any)._classRegistryKey) continue;
+    register(`Expression_${name}`, expressions[name]);
+}
+
+function isArrayBuffer(val: any): boolean {
+    return val && typeof ArrayBuffer !== 'undefined' &&
+           (val instanceof ArrayBuffer || (val.constructor && val.constructor.name === 'ArrayBuffer'));
+}
+
+function isImageBitmap(val: any): boolean {
+    return ImageBitmap &&
+        val instanceof ImageBitmap;
+}
+
+/**
+ * Serialize the given object for transfer to or from a web worker.
+ *
+ * For non-builtin types, recursively serialize each property (possibly
+ * omitting certain properties - see register()), and package the result along
+ * with the constructor's `name` so that the appropriate constructor can be
+ * looked up in `deserialize()`.
+ *
+ * If a `transferables` array is provided, add any transferable objects (i.e.,
+ * any ArrayBuffers or ArrayBuffer views) to the list. (If a copy is needed,
+ * this should happen in the client code, before using serialize().)
+ *
+ * @private
+ */
+export function serialize(input: mixed, transferables: ?Array<Transferable>): Serialized {
+    if (input === null ||
+        input === undefined ||
+        typeof input === 'boolean' ||
+        typeof input === 'number' ||
+        typeof input === 'string' ||
+        input instanceof Boolean ||
+        input instanceof Number ||
+        input instanceof String ||
+        input instanceof Date ||
+        input instanceof RegExp) {
+        return input;
+    }
+
+    if (isArrayBuffer(input) || isImageBitmap(input)) {
+        if (transferables) {
+            transferables.push(((input: any): ArrayBuffer));
+        }
+        return input;
+    }
+
+    if (ArrayBuffer.isView(input)) {
+        const view: $ArrayBufferView = (input: any);
+        if (transferables) {
+            transferables.push(view.buffer);
+        }
+        return view;
+    }
+
+    if (input instanceof ImageData) {
+        if (transferables) {
+            transferables.push(input.data.buffer);
+        }
+        return input;
+    }
+
+    if (Array.isArray(input)) {
+        const serialized: Array<Serialized> = [];
+        for (const item of input) {
+            serialized.push(serialize(item, transferables));
+        }
+        return serialized;
+    }
+
+    if (typeof input === 'object') {
+        const klass = (input.constructor: any);
+        const name = klass._classRegistryKey;
+        if (!name) {
+            throw new Error(`can't serialize object of unregistered class`);
+        }
+        assert(registry[name]);
+
+        const properties: SerializedObject = klass.serialize ?
+            // (Temporary workaround) allow a class to provide static
+            // `serialize()` and `deserialize()` methods to bypass the generic
+            // approach.
+            // This temporary workaround lets us use the generic serialization
+            // approach for objects whose members include instances of dynamic
+            // StructArray types. Once we refactor StructArray to be static,
+            // we can remove this complexity.
+            (klass.serialize(input, transferables): SerializedObject) : {};
+
+        if (!klass.serialize) {
+            for (const key in input) {
+                // any cast due to https://github.com/facebook/flow/issues/5393
+                if (!(input: any).hasOwnProperty(key)) continue;
+                if (registry[name].omit.indexOf(key) >= 0) continue;
+                const property = (input: any)[key];
+                properties[key] = registry[name].shallow.indexOf(key) >= 0 ?
+                    property :
+                    serialize(property, transferables);
+            }
+            if (input instanceof Error) {
+                properties.message = input.message;
+            }
+        } else {
+            // make sure statically serialized object survives transfer of $name property
+            assert(!transferables || properties !== transferables[transferables.length - 1]);
+        }
+
+        if (properties.$name) {
+            throw new Error('$name property is reserved for worker serialization logic.');
+        }
+        if (name !== 'Object') {
+            properties.$name = name;
+        }
+
+        return properties;
+    }
+
+    throw new Error(`can't serialize object of type ${typeof input}`);
+}
+
+export function deserialize(input: Serialized): mixed {
+    if (input === null ||
+        input === undefined ||
+        typeof input === 'boolean' ||
+        typeof input === 'number' ||
+        typeof input === 'string' ||
+        input instanceof Boolean ||
+        input instanceof Number ||
+        input instanceof String ||
+        input instanceof Date ||
+        input instanceof RegExp ||
+        isArrayBuffer(input) ||
+        isImageBitmap(input) ||
+        ArrayBuffer.isView(input) ||
+        input instanceof ImageData) {
+        return input;
+    }
+
+    if (Array.isArray(input)) {
+        return input.map(deserialize);
+    }
+
+    if (typeof input === 'object') {
+        const name = (input: any).$name || 'Object';
+
+        const {klass} = registry[name];
+        if (!klass) {
+            throw new Error(`can't deserialize unregistered class ${name}`);
+        }
+
+        if (klass.deserialize) {
+            return (klass.deserialize: typeof deserialize)(input);
+        }
+
+        const result = Object.create(klass.prototype);
+
+        for (const key of Object.keys(input)) {
+            if (key === '$name') continue;
+            const value = (input: SerializedObject)[key];
+            result[key] = registry[name].shallow.indexOf(key) >= 0 ? value : deserialize(value);
+        }
+
+        return result;
+    }
+
+    throw new Error(`can't deserialize object of type ${typeof input}`);
+}

package/src/util/webp_supported.js

@@ -0,0 +1,69 @@
+// @flow strict
+
+import window from './window';
+
+const exported = {
+    supported: false,
+    testSupport
+};
+
+export default exported;
+
+let glForTesting;
+let webpCheckComplete = false;
+let webpImgTest;
+let webpImgTestOnloadComplete = false;
+
+if (window.document) {
+    webpImgTest = window.document.createElement('img');
+    webpImgTest.onload = function() {
+        if (glForTesting) testWebpTextureUpload(glForTesting);
+        glForTesting = null;
+        webpImgTestOnloadComplete = true;
+    };
+    webpImgTest.onerror = function() {
+        webpCheckComplete = true;
+        glForTesting = null;
+    };
+    webpImgTest.src = 'data:image/webp;base64,UklGRh4AAABXRUJQVlA4TBEAAAAvAQAAAAfQ//73v/+BiOh/AAA=';
+}
+
+function testSupport(gl: WebGLRenderingContext) {
+    if (webpCheckComplete || !webpImgTest) return;
+
+    // HTMLImageElement.complete is set when an image is done loading it's source
+    // regardless of whether the load was successful or not.
+    // It's possible for an error to set HTMLImageElement.complete to true which would trigger
+    // testWebpTextureUpload and mistakenly set exported.supported to true in browsers which don't support webp
+    // To avoid this, we set a flag in the image's onload handler and only call testWebpTextureUpload
+    // after a successful image load event.
+    if (webpImgTestOnloadComplete) {
+        testWebpTextureUpload(gl);
+    } else {
+        glForTesting = gl;
+
+    }
+}
+
+function testWebpTextureUpload(gl: WebGLRenderingContext) {
+    // Edge 18 supports WebP but not uploading a WebP image to a gl texture
+    // Test support for this before allowing WebP images.
+    // https://github.com/mapbox/mapbox-gl-js/issues/7671
+    const texture = gl.createTexture();
+    gl.bindTexture(gl.TEXTURE_2D, texture);
+
+    try {
+        gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, webpImgTest);
+
+        // The error does not get triggered in Edge if the context is lost
+        if (gl.isContextLost()) return;
+
+        exported.supported = true;
+    } catch (e) {
+        // Catch "Unspecified Error." in Edge 18.
+    }
+
+    gl.deleteTexture(texture);
+
+    webpCheckComplete = true;
+}

package/src/util/window.js

@@ -0,0 +1,102 @@
+// @flow strict
+
+// This file is intended for use in the GL-JS test suite
+// It implements a JSDOM window object for use in Node environments
+// In a browser environment, this file is replaced with ./src/util/browser/window.js
+// when Rollup builds the main bundle
+// See package.json#browser
+
+import jsdom from 'jsdom';
+
+import gl from 'gl';
+import sinon from 'sinon';
+
+import type {Window} from '../types/window';
+
+const {window: _window} = new jsdom.JSDOM('', {
+    virtualConsole: new jsdom.VirtualConsole().sendTo(console)
+});
+
+restore();
+
+export default _window;
+
+function restore(): Window {
+    // Remove previous window from exported object
+    const previousWindow = _window;
+    if (previousWindow.close) previousWindow.close();
+    for (const key in previousWindow) {
+        if (previousWindow.hasOwnProperty(key)) {
+            delete previousWindow[key];
+        }
+    }
+
+    // Create new window and inject into exported object
+    const {window} = new jsdom.JSDOM('', {
+        // Send jsdom console output to the node console object.
+        virtualConsole: new jsdom.VirtualConsole().sendTo(console)
+    });
+
+    // Delete local and session storage from JSDOM and stub them out with a warning log
+    // Accessing these properties during extend() produces an error in Node environments
+    // See https://github.com/mapbox/mapbox-gl-js/pull/7455 for discussion
+    delete window.localStorage;
+    delete window.sessionStorage;
+    window.localStorage = window.sessionStorage = () => console.log('Local and session storage not available in Node. Use a stub implementation if needed for testing.');
+
+    window.devicePixelRatio = 1;
+
+    window.requestAnimationFrame = function(callback) {
+        return setImmediate(callback, 0);
+    };
+    window.cancelAnimationFrame = clearImmediate;
+
+    // Add webgl context with the supplied GL
+    const originalGetContext = window.HTMLCanvasElement.prototype.getContext;
+    window.HTMLCanvasElement.prototype.getContext = function (type, attributes) {
+        if (type === 'webgl') {
+            if (!this._webGLContext) {
+                this._webGLContext = gl(this.width, this.height, attributes);
+            }
+            return this._webGLContext;
+        }
+        // Fallback to existing HTMLCanvasElement getContext behaviour
+        return originalGetContext.call(this, type, attributes);
+    };
+
+    window.useFakeHTMLCanvasGetContext = function() {
+        this.HTMLCanvasElement.prototype.getContext = function() { return '2d'; };
+    };
+
+    window.useFakeXMLHttpRequest = function() {
+        sinon.xhr.supportsCORS = true;
+        this.server = sinon.fakeServer.create();
+        this.XMLHttpRequest = this.server.xhr;
+    };
+
+    window.URL.revokeObjectURL = function () {};
+
+    window.fakeWorkerPresence = function() {
+        global.WorkerGlobalScope = function() {};
+        global.self = new global.WorkerGlobalScope();
+    };
+    window.clearFakeWorkerPresence = function() {
+        global.WorkerGlobalScope = undefined;
+        global.self = undefined;
+    };
+
+    window.restore = restore;
+
+    window.performance.getEntriesByName = function() {};
+    window.performance.mark = function() {};
+    window.performance.measure = function() {};
+    window.performance.clearMarks = function() {};
+    window.performance.clearMeasures = function() {};
+
+    window.ImageData = window.ImageData || function() { return false; };
+    window.ImageBitmap = window.ImageBitmap || function() { return false; };
+    window.WebGLFramebuffer = window.WebGLFramebuffer || Object;
+    Object.assign(_window, window); // eslint-disable-line no-restricted-properties
+
+    return window;
+}