mapbox-gl 1.13.2

package/src/symbol/symbol_size.js

@@ -0,0 +1,113 @@
+// @flow
+
+import {number as interpolate} from '../style-spec/util/interpolate';
+import Interpolate from '../style-spec/expression/definitions/interpolate';
+import {clamp} from '../util/util';
+import EvaluationParameters from '../style/evaluation_parameters';
+
+import type {PropertyValue, PossiblyEvaluatedPropertyValue} from '../style/properties';
+import type {InterpolationType} from '../style-spec/expression/definitions/interpolate';
+
+const SIZE_PACK_FACTOR = 128;
+
+export {getSizeData, evaluateSizeForFeature, evaluateSizeForZoom, SIZE_PACK_FACTOR};
+
+export type SizeData = {
+    kind: 'constant',
+    layoutSize: number
+} | {
+    kind: 'source'
+} | {
+    kind: 'camera',
+    minZoom: number,
+    maxZoom: number,
+    minSize: number,
+    maxSize: number,
+    interpolationType: ?InterpolationType
+} | {
+    kind: 'composite',
+    minZoom: number,
+    maxZoom: number,
+    interpolationType: ?InterpolationType
+};
+
+// For {text,icon}-size, get the bucket-level data that will be needed by
+// the painter to set symbol-size-related uniforms
+function getSizeData(tileZoom: number, value: PropertyValue<number, PossiblyEvaluatedPropertyValue<number>>): SizeData {
+    const {expression} = value;
+
+    if (expression.kind === 'constant') {
+        const layoutSize = expression.evaluate(new EvaluationParameters(tileZoom + 1));
+        return {kind: 'constant', layoutSize};
+
+    } else if (expression.kind === 'source') {
+        return {kind: 'source'};
+
+    } else {
+        const {zoomStops, interpolationType} = expression;
+
+        // calculate covering zoom stops for zoom-dependent values
+        let lower = 0;
+        while (lower < zoomStops.length && zoomStops[lower] <= tileZoom) lower++;
+        lower = Math.max(0, lower - 1);
+        let upper = lower;
+        while (upper < zoomStops.length && zoomStops[upper] < tileZoom + 1) upper++;
+        upper = Math.min(zoomStops.length - 1, upper);
+
+        const minZoom = zoomStops[lower];
+        const maxZoom = zoomStops[upper];
+
+        // We'd like to be able to use CameraExpression or CompositeExpression in these
+        // return types rather than ExpressionSpecification, but the former are not
+        // transferrable across Web Worker boundaries.
+        if (expression.kind === 'composite') {
+            return {kind: 'composite', minZoom, maxZoom, interpolationType};
+        }
+
+        // for camera functions, also save off the function values
+        // evaluated at the covering zoom levels
+        const minSize = expression.evaluate(new EvaluationParameters(minZoom));
+        const maxSize = expression.evaluate(new EvaluationParameters(maxZoom));
+
+        return {kind: 'camera', minZoom, maxZoom, minSize, maxSize, interpolationType};
+    }
+}
+
+function evaluateSizeForFeature(sizeData: SizeData,
+                                {uSize, uSizeT}: { uSize: number, uSizeT: number },
+                                {lowerSize, upperSize}: { lowerSize: number, upperSize: number}) {
+    if (sizeData.kind === 'source') {
+        return lowerSize / SIZE_PACK_FACTOR;
+    } else if (sizeData.kind === 'composite') {
+        return interpolate(lowerSize / SIZE_PACK_FACTOR, upperSize / SIZE_PACK_FACTOR, uSizeT);
+    }
+    return uSize;
+}
+
+function evaluateSizeForZoom(sizeData: SizeData, zoom: number) {
+    let uSizeT = 0;
+    let uSize = 0;
+
+    if (sizeData.kind === 'constant') {
+        uSize = sizeData.layoutSize;
+
+    } else if (sizeData.kind !== 'source') {
+        const {interpolationType, minZoom, maxZoom} = sizeData;
+
+        // Even though we could get the exact value of the camera function
+        // at z = tr.zoom, we intentionally do not: instead, we interpolate
+        // between the camera function values at a pair of zoom stops covering
+        // [tileZoom, tileZoom + 1] in order to be consistent with this
+        // restriction on composite functions
+        const t = !interpolationType ? 0 : clamp(
+            Interpolate.interpolationFactor(interpolationType, zoom, minZoom, maxZoom), 0, 1);
+
+        if (sizeData.kind === 'camera') {
+            uSize = interpolate(sizeData.minSize, sizeData.maxSize, t);
+        } else {
+            uSizeT = t;
+        }
+    }
+
+    return {uSizeT, uSize};
+}

package/src/symbol/transform_text.js

@@ -0,0 +1,29 @@
+// @flow
+
+import {plugin as rtlTextPlugin} from '../source/rtl_text_plugin';
+
+import type SymbolStyleLayer from '../style/style_layer/symbol_style_layer';
+import type {Feature} from '../style-spec/expression';
+import Formatted from '../style-spec/expression/types/formatted';
+
+function transformText(text: string, layer: SymbolStyleLayer, feature: Feature) {
+    const transform = layer.layout.get('text-transform').evaluate(feature, {});
+    if (transform === 'uppercase') {
+        text = text.toLocaleUpperCase();
+    } else if (transform === 'lowercase') {
+        text = text.toLocaleLowerCase();
+    }
+
+    if (rtlTextPlugin.applyArabicShaping) {
+        text = rtlTextPlugin.applyArabicShaping(text);
+    }
+
+    return text;
+}
+
+export default function(text: Formatted, layer: SymbolStyleLayer, feature: Feature): Formatted {
+    text.sections.forEach(section => {
+        section.text = transformText(section.text, layer, feature);
+    });
+    return text;
+}

package/src/types/callback.js

@@ -0,0 +1,17 @@
+// @flow strict
+
+// Flow can't perfectly type Node-style callbacks yet; it does not have a way to
+// express that if the first parameter is null, the second is not, so for the time
+// being, both parameters must be optional. Use the following convention when defining
+// a callback:
+//
+//    asyncFunction((error, result) => {
+//        if (error) {
+//            // handle error
+//        } else if (result) {
+//            // handle success
+//        }
+//    });
+//
+// See https://github.com/facebook/flow/issues/2123 for more.
+export type Callback<T> = (error: ?Error, result: ?T) => void;

package/src/types/cancelable.js

@@ -0,0 +1,3 @@
+// @flow strict
+
+export type Cancelable = { cancel: () => void };

package/src/types/tilejson.js

@@ -0,0 +1,17 @@
+// @flow
+
+export type TileJSON = {|
+    tilejson: '2.2.0' | '2.1.0' | '2.0.1' | '2.0.0' | '1.0.0',
+    name?: string,
+    description?: string,
+    version?: string,
+    attribution?: string,
+    template?: string,
+    tiles: Array<string>,
+    grids?: Array<string>,
+    data?: Array<string>,
+    minzoom?: number,
+    maxzoom?: number,
+    bounds?: [number, number, number, number],
+    center?: [number, number, number]
+|};

package/src/types/transferable.js

@@ -0,0 +1,3 @@
+// @flow
+
+export type Transferable = ArrayBuffer | MessagePort | ImageBitmap;

package/src/types/window.js

@@ -0,0 +1,172 @@
+// @flow strict
+
+/* global EventTarget, IDBEnvironment */
+
+export interface Window extends EventTarget, IDBEnvironment {
+    +caches: CacheStorage;
+    +clientInformation: Navigator;
+    +closed: boolean;
+    defaultStatus: string;
+    +devicePixelRatio: number;
+    +document: Document;
+    +doNotTrack: string;
+    +frameElement: Element;
+    +frames: Window;
+    +history: History;
+    +innerHeight: number;
+    +innerWidth: number;
+    +isSecureContext: boolean;
+    +length: number;
+    +location: Location;
+    +origin: string;
+    name: string;
+    +navigator: Navigator;
+    offscreenBuffering: string | boolean;
+    onabort: (ev: UIEvent) => ?boolean;
+    onafterprint: (ev: Event) => ?boolean;
+    onbeforeprint: (ev: Event) => ?boolean;
+    onbeforeunload: (ev: Event) => ?boolean;
+    onblur: (ev: FocusEvent) => ?boolean;
+    oncanplay: (ev: Event) => ?boolean;
+    oncanplaythrough: (ev: Event) => ?boolean;
+    onchange: (ev: Event) => ?boolean;
+    onclick: (ev: MouseEvent) => ?boolean;
+    oncompassneedscalibration: (ev: Event) => ?boolean;
+    oncontextmenu: (ev: Event) => ?boolean;
+    ondblclick: (ev: MouseEvent) => ?boolean;
+    ondevicelight: (ev: Event) => ?boolean;
+    ondevicemotion: (ev: Event) => ?boolean;
+    ondeviceorientation: (ev: Event) => ?boolean;
+    ondrag: (ev: DragEvent) => ?boolean;
+    ondragend: (ev: DragEvent) => ?boolean;
+    ondragenter: (ev: DragEvent) => ?boolean;
+    ondragleave: (ev: DragEvent) => ?boolean;
+    ondragover: (ev: DragEvent) => ?boolean;
+    ondragstart: (ev: DragEvent) => ?boolean;
+    ondrop: (ev: DragEvent) => ?boolean;
+    ondurationchange: (ev: Event) => ?boolean;
+    onemptied: (ev: Event) => ?boolean;
+    onended: (ev: Event) => ?boolean;
+    onerror: (ev: Event) => ?boolean;
+    onfocus: (ev: FocusEvent) => ?boolean;
+    onhashchange: (ev: Event) => ?boolean;
+    oninput: (ev: Event) => ?boolean;
+    oninvalid: (ev: Event) => ?boolean;
+    onkeydown: (ev: KeyboardEvent) => ?boolean;
+    onkeypress: (ev: KeyboardEvent) => ?boolean;
+    onkeyup: (ev: KeyboardEvent) => ?boolean;
+    onload: (ev: Event) => ?boolean;
+    onloadeddata: (ev: Event) => ?boolean;
+    onloadedmetadata: (ev: Event) => ?boolean;
+    onloadstart: (ev: Event) => ?boolean;
+    onmessage: (ev: MessageEvent) => ?boolean;
+    onmousedown: (ev: MouseEvent) => ?boolean;
+    onmouseenter: (ev: MouseEvent) => ?boolean;
+    onmouseleave: (ev: MouseEvent) => ?boolean;
+    onmousemove: (ev: MouseEvent) => ?boolean;
+    onmouseout: (ev: MouseEvent) => ?boolean;
+    onmouseover: (ev: MouseEvent) => ?boolean;
+    onmouseup: (ev: MouseEvent) => ?boolean;
+    onmousewheel: (ev: WheelEvent) => ?boolean;
+    onoffline: (ev: Event) => ?boolean;
+    ononline: (ev: Event) => ?boolean;
+    onorientationchange: (ev: Event) => ?boolean;
+    onpagehide: (ev: Event) => ?boolean;
+    onpageshow: (ev: Event) => ?boolean;
+    onpause: (ev: Event) => ?boolean;
+    onplay: (ev: Event) => ?boolean;
+    onplaying: (ev: Event) => ?boolean;
+    onpopstate: (ev: Event) => ?boolean;
+    onprogress: (ev: ProgressEvent) => ?boolean;
+    onratechange: (ev: Event) => ?boolean;
+    onreadystatechange: (ev: ProgressEvent) => ?boolean;
+    onreset: (ev: Event) => ?boolean;
+    onresize: (ev: UIEvent) => ?boolean;
+    onscroll: (ev: UIEvent) => ?boolean;
+    onseeked: (ev: Event) => ?boolean;
+    onseeking: (ev: Event) => ?boolean;
+    onselect: (ev: UIEvent) => ?boolean;
+    onstalled: (ev: Event) => ?boolean;
+    onstorage: (ev: Event) => ?boolean;
+    onsubmit: (ev: Event) => ?boolean;
+    onsuspend: (ev: Event) => ?boolean;
+    ontimeupdate: (ev: Event) => ?boolean;
+    ontouchcancel: (ev: TouchEvent) => ?boolean;
+    ontouchend: (ev: TouchEvent) => ?boolean;
+    ontouchmove: (ev: TouchEvent) => ?boolean;
+    ontouchstart: (ev: TouchEvent) => ?boolean;
+    onunload: (ev: Event) => ?boolean;
+    onvolumechange: (ev: Event) => ?boolean;
+    onwaiting: (ev: Event) => ?boolean;
+    opener: Window;
+    orientation: string | number;
+    +outerHeight: number;
+    +outerWidth: number;
+    +pageXOffset: number;
+    +pageYOffset: number;
+    +parent: Window;
+    +performance: Performance;
+    +screen: Screen;
+    +screenLeft: number;
+    +screenTop: number;
+    +screenX: number;
+    +screenY: number;
+    +scrollX: number;
+    +scrollY: number;
+    +self: Window;
+    status: string;
+    +top: Window;
+    +window: Window;
+
+    Blob: typeof Blob;
+    HTMLImageElement: typeof HTMLImageElement;
+    HTMLElement: typeof HTMLElement;
+    HTMLVideoElement: typeof HTMLVideoElement;
+    HTMLCanvasElement: typeof HTMLCanvasElement;
+    Image: typeof Image;
+    ImageData: typeof ImageData;
+    URL: typeof URL;
+    URLSearchParams: typeof URLSearchParams;
+    WebGLFramebuffer: typeof WebGLFramebuffer;
+    WheelEvent: typeof WheelEvent;
+    Worker: typeof Worker;
+    XMLHttpRequest: typeof XMLHttpRequest;
+    Request: typeof Request;
+    AbortController: typeof AbortController;
+
+    alert(message?: string): void;
+    blur(): void;
+    captureEvents(): void;
+    close(): void;
+    confirm(message?: string): boolean;
+    focus(): void;
+    getComputedStyle(elt: Element, pseudoElt?: string): CSSStyleDeclaration;
+    getMatchedCSSRules(elt: Element, pseudoElt?: string): CSSRuleList;
+    getSelection(): Selection;
+    moveBy(x?: number, y?: number): void;
+    moveTo(x?: number, y?: number): void;
+    msWriteProfilerMark(profilerMarkName: string): void;
+    open(url?: string, target?: string, features?: string, replace?: boolean): Window;
+    postMessage(message: mixed, targetOrigin: string, transfer?: ArrayBuffer[]): void;
+    print(): void;
+    prompt(message?: string, _default?: string): string | null;
+    releaseEvents(): void;
+    resizeBy(x?: number, y?: number): void;
+    resizeTo(x?: number, y?: number): void;
+    scroll(x?: number, y?: number): void;
+    scrollBy(x?: number, y?: number): void;
+    scrollTo(x?: number, y?: number): void;
+    stop(): void;
+
+    clearInterval(intervalId?: number): void;
+    clearTimeout(timeoutId?: number): void;
+    setTimeout(callback: () => void, ms?: number): number;
+    setInterval(callback: () => void, ms?: number): number;
+
+    requestAnimationFrame(callback: (timestamp: number) => void): number;
+    cancelAnimationFrame(handle: number): void;
+    msRequestAnimationFrame(callback: (timestamp: number) => void): number;
+    msCancelAnimationFrame(handle: number): void;
+    webkitRequestAnimationFrame(callback: (timestamp: number) => void): number;
+    webkitCancelAnimationFrame(handle: number): void;
+}

package/src/ui/anchor.js

@@ -0,0 +1,32 @@
+// @flow
+
+export type Anchor =
+    | 'center'
+    | 'top'
+    | 'bottom'
+    | 'left'
+    | 'right'
+    | 'top-left'
+    | 'top-right'
+    | 'bottom-left'
+    | 'bottom-right';
+
+export const anchorTranslate: {[_: Anchor]: string} = {
+    'center': 'translate(-50%,-50%)',
+    'top': 'translate(-50%,0)',
+    'top-left': 'translate(0,0)',
+    'top-right': 'translate(-100%,0)',
+    'bottom': 'translate(-50%,-100%)',
+    'bottom-left': 'translate(0,-100%)',
+    'bottom-right': 'translate(-100%,-100%)',
+    'left': 'translate(0,-50%)',
+    'right': 'translate(-100%,-50%)'
+};
+
+export function applyAnchorClass(element: HTMLElement, anchor: Anchor, prefix: string) {
+    const classList = element.classList;
+    for (const key in anchorTranslate) {
+        classList.remove(`mapboxgl-${prefix}-anchor-${key}`);
+    }
+    classList.add(`mapboxgl-${prefix}-anchor-${anchor}`);
+}