@mapgis/mapbox-gl 16.0.1 → 16.2.0

package/src/symbol/symbol_size.js

@@ -1,113 +0,0 @@
-// @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

@@ -1,29 +0,0 @@
-// @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

@@ -1,17 +0,0 @@
-// @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

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

package/src/types/tilejson.js

@@ -1,17 +0,0 @@
-// @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

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

package/src/types/window.js

@@ -1,172 +0,0 @@
-// @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

@@ -1,32 +0,0 @@
-// @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}`);
-}

package/src/ui/bind_handlers.js

@@ -1,202 +0,0 @@
-// @flow
-
-import {MapMouseEvent, MapTouchEvent, MapWheelEvent} from '../ui/events';
-import DOM from '../util/dom';
-import type Map from './map';
-import scrollZoom from './handler/scroll_zoom';
-import boxZoom from './handler/box_zoom';
-import dragRotate from './handler/drag_rotate';
-import dragPan from './handler/drag_pan';
-import keyboard from './handler/keyboard';
-import doubleClickZoom from './handler/dblclick_zoom';
-import touchZoomRotate from './handler/touch_zoom_rotate';
-
-const handlers = {
-    scrollZoom,
-    boxZoom,
-    dragRotate,
-    dragPan,
-    keyboard,
-    doubleClickZoom,
-    touchZoomRotate
-};
-
-export default function bindHandlers(map: Map, options: {interactive: boolean, clickTolerance: number}) {
-    const el = map.getCanvasContainer();
-    let contextMenuEvent = null;
-    let mouseDown = false;
-    let startPos = null;
-
-    for (const name in handlers) {
-        (map: any)[name] = new handlers[name](map, options);
-        if (options.interactive && options[name]) {
-            (map: any)[name].enable(options[name]);
-        }
-    }
-
-    DOM.addEventListener(el, 'mouseout', onMouseOut);
-    DOM.addEventListener(el, 'mousedown', onMouseDown);
-    DOM.addEventListener(el, 'mouseup', onMouseUp);
-    DOM.addEventListener(el, 'mousemove', onMouseMove);
-    DOM.addEventListener(el, 'mouseover', onMouseOver);
-
-    // Bind touchstart and touchmove with passive: false because, even though
-    // they only fire a map events and therefore could theoretically be
-    // passive, binding with passive: true causes iOS not to respect
-    // e.preventDefault() in _other_ handlers, even if they are non-passive
-    // (see https://bugs.webkit.org/show_bug.cgi?id=184251)
-    DOM.addEventListener(el, 'touchstart', onTouchStart, {passive: false});
-    DOM.addEventListener(el, 'touchmove', onTouchMove, {passive: false});
-
-    DOM.addEventListener(el, 'touchend', onTouchEnd);
-    DOM.addEventListener(el, 'touchcancel', onTouchCancel);
-    DOM.addEventListener(el, 'click', onClick);
-    DOM.addEventListener(el, 'dblclick', onDblClick);
-    DOM.addEventListener(el, 'contextmenu', onContextMenu);
-    DOM.addEventListener(el, 'wheel', onWheel, {passive: false});
-
-    function onMouseDown(e: MouseEvent) {
-        mouseDown = true;
-        startPos = DOM.mousePos(el, e);
-
-        const mapEvent = new MapMouseEvent('mousedown', map, e);
-        map.fire(mapEvent);
-
-        if (mapEvent.defaultPrevented) {
-            return;
-        }
-
-        if (options.interactive && !map.doubleClickZoom.isActive()) {
-            map.stop();
-        }
-
-        map.boxZoom.onMouseDown(e);
-
-        if (!map.boxZoom.isActive() && !map.dragPan.isActive()) {
-            map.dragRotate.onMouseDown(e);
-        }
-
-        if (!map.boxZoom.isActive() && !map.dragRotate.isActive()) {
-            map.dragPan.onMouseDown(e);
-        }
-    }
-
-    function onMouseUp(e: MouseEvent) {
-        const rotating = map.dragRotate.isActive();
-
-        if (contextMenuEvent && !rotating) {
-            // This will be the case for Mac
-            map.fire(new MapMouseEvent('contextmenu', map, contextMenuEvent));
-        }
-
-        contextMenuEvent = null;
-        mouseDown = false;
-
-        map.fire(new MapMouseEvent('mouseup', map, e));
-    }
-
-    function onMouseMove(e: MouseEvent) {
-        if (map.dragPan.isActive()) return;
-        if (map.dragRotate.isActive()) return;
-
-        let target: ?Node = (e.target: any);
-        while (target && target !== el) target = target.parentNode;
-        if (target !== el) return;
-
-        map.fire(new MapMouseEvent('mousemove', map, e));
-    }
-
-    function onMouseOver(e: MouseEvent) {
-        let target: ?Node = (e.target: any);
-        while (target && target !== el) target = target.parentNode;
-        if (target !== el) return;
-
-        map.fire(new MapMouseEvent('mouseover', map, e));
-    }
-
-    function onMouseOut(e: MouseEvent) {
-        map.fire(new MapMouseEvent('mouseout', map, e));
-    }
-
-    function onTouchStart(e: TouchEvent) {
-        const mapEvent = new MapTouchEvent('touchstart', map, e);
-        map.fire(mapEvent);
-
-        if (mapEvent.defaultPrevented) {
-            return;
-        }
-
-        if (options.interactive) {
-            map.stop();
-        }
-
-        if (!map.boxZoom.isActive() && !map.dragRotate.isActive()) {
-            map.dragPan.onTouchStart(e);
-        }
-
-        map.touchZoomRotate.onStart(e);
-        map.doubleClickZoom.onTouchStart(mapEvent);
-    }
-
-    function onTouchMove(e: TouchEvent) {
-        map.fire(new MapTouchEvent('touchmove', map, e));
-    }
-
-    function onTouchEnd(e: TouchEvent) {
-        map.fire(new MapTouchEvent('touchend', map, e));
-    }
-
-    function onTouchCancel(e: TouchEvent) {
-        map.fire(new MapTouchEvent('touchcancel', map, e));
-    }
-
-    function onClick(e: MouseEvent) {
-        const pos = DOM.mousePos(el, e);
-        if (!startPos || pos.equals(startPos) || pos.dist(startPos) < options.clickTolerance) {
-            map.fire(new MapMouseEvent('click', map, e));
-        }
-    }
-
-    function onDblClick(e: MouseEvent) {
-        const mapEvent = new MapMouseEvent('dblclick', map, e);
-        map.fire(mapEvent);
-
-        if (mapEvent.defaultPrevented) {
-            return;
-        }
-
-        map.doubleClickZoom.onDblClick(mapEvent);
-    }
-
-    function onContextMenu(e: MouseEvent) {
-        const rotating = map.dragRotate.isActive();
-        if (!mouseDown && !rotating) {
-            // Windows: contextmenu fired on mouseup, so fire event now
-            map.fire(new MapMouseEvent('contextmenu', map, e));
-        } else if (mouseDown) {
-            // Mac: contextmenu fired on mousedown; we save it until mouseup for consistency's sake
-            contextMenuEvent = e;
-        }
-
-        // prevent browser context menu when necessary; we don't allow it with rotation
-        // because we can't discern rotation gesture start from contextmenu on Mac
-        if (map.dragRotate.isEnabled() || map.listens('contextmenu')) {
-            e.preventDefault();
-        }
-    }
-
-    function onWheel(e: WheelEvent) {
-        if (options.interactive) {
-            map.stop();
-        }
-
-        const mapEvent = new MapWheelEvent('wheel', map, e);
-        map.fire(mapEvent);
-
-        if (mapEvent.defaultPrevented) {
-            return;
-        }
-
-        map.scrollZoom.onWheel(e);
-    }
-}