@mapgis/mapbox-gl 16.0.0 → 16.2.0

package/src/util/primitives.js

@@ -1,145 +0,0 @@
-// @flow
-
-import {vec3, vec4} from 'gl-matrix';
-import assert from 'assert';
-
-class Frustum {
-    points: Array<Array<number>>;
-    planes: Array<Array<number>>;
-
-    constructor(points_: Array<Array<number>>, planes_: Array<Array<number>>) {
-        this.points = points_;
-        this.planes = planes_;
-    }
-
-    static fromInvProjectionMatrix(invProj: Float64Array, worldSize: number, zoom: number): Frustum {
-        const clipSpaceCorners = [
-            [-1, 1, -1, 1],
-            [ 1, 1, -1, 1],
-            [ 1, -1, -1, 1],
-            [-1, -1, -1, 1],
-            [-1, 1, 1, 1],
-            [ 1, 1, 1, 1],
-            [ 1, -1, 1, 1],
-            [-1, -1, 1, 1]
-        ];
-
-        const scale = Math.pow(2, zoom);
-
-        // Transform frustum corner points from clip space to tile space
-        const frustumCoords = clipSpaceCorners
-            .map(v => vec4.transformMat4([], v, invProj))
-            .map(v => vec4.scale([], v, 1.0 / v[3] / worldSize * scale));
-
-        const frustumPlanePointIndices = [
-            [0, 1, 2],  // near
-            [6, 5, 4],  // far
-            [0, 3, 7],  // left
-            [2, 1, 5],  // right
-            [3, 2, 6],  // bottom
-            [0, 4, 5]   // top
-        ];
-
-        const frustumPlanes = frustumPlanePointIndices.map((p: Array<number>) => {
-            const a = vec3.sub([], frustumCoords[p[0]], frustumCoords[p[1]]);
-            const b = vec3.sub([], frustumCoords[p[2]], frustumCoords[p[1]]);
-            const n = vec3.normalize([], vec3.cross([], a, b));
-            const d = -vec3.dot(n, frustumCoords[p[1]]);
-            return n.concat(d);
-        });
-
-        return new Frustum(frustumCoords, frustumPlanes);
-    }
-}
-
-class Aabb {
-    min: vec3;
-    max: vec3;
-    center: vec3;
-
-    constructor(min_: vec3, max_: vec3) {
-        this.min = min_;
-        this.max = max_;
-        this.center = vec3.scale([], vec3.add([], this.min, this.max), 0.5);
-    }
-
-    quadrant(index: number): Aabb {
-        const split = [(index % 2) === 0, index < 2];
-        const qMin = vec3.clone(this.min);
-        const qMax = vec3.clone(this.max);
-        for (let axis = 0; axis < split.length; axis++) {
-            qMin[axis] = split[axis] ? this.min[axis] : this.center[axis];
-            qMax[axis] = split[axis] ? this.center[axis] : this.max[axis];
-        }
-        // Elevation is always constant, hence quadrant.max.z = this.max.z
-        qMax[2] = this.max[2];
-        return new Aabb(qMin, qMax);
-    }
-
-    distanceX(point: Array<number>): number {
-        const pointOnAabb = Math.max(Math.min(this.max[0], point[0]), this.min[0]);
-        return pointOnAabb - point[0];
-    }
-
-    distanceY(point: Array<number>): number {
-        const pointOnAabb = Math.max(Math.min(this.max[1], point[1]), this.min[1]);
-        return pointOnAabb - point[1];
-    }
-
-    // Performs a frustum-aabb intersection test. Returns 0 if there's no intersection,
-    // 1 if shapes are intersecting and 2 if the aabb if fully inside the frustum.
-    intersects(frustum: Frustum): number {
-        // Execute separating axis test between two convex objects to find intersections
-        // Each frustum plane together with 3 major axes define the separating axes
-        // Note: test only 4 points as both min and max points have equal elevation
-        assert(this.min[2] === 0 && this.max[2] === 0);
-
-        const aabbPoints = [
-            [this.min[0], this.min[1], 0.0, 1],
-            [this.max[0], this.min[1], 0.0, 1],
-            [this.max[0], this.max[1], 0.0, 1],
-            [this.min[0], this.max[1], 0.0, 1]
-        ];
-
-        let fullyInside = true;
-
-        for (let p = 0; p < frustum.planes.length; p++) {
-            const plane = frustum.planes[p];
-            let pointsInside = 0;
-
-            for (let i = 0; i < aabbPoints.length; i++) {
-                pointsInside += vec4.dot(plane, aabbPoints[i]) >= 0;
-            }
-
-            if (pointsInside === 0)
-                return 0;
-
-            if (pointsInside !== aabbPoints.length)
-                fullyInside = false;
-        }
-
-        if (fullyInside)
-            return 2;
-
-        for (let axis = 0; axis < 3; axis++) {
-            let projMin = Number.MAX_VALUE;
-            let projMax = -Number.MAX_VALUE;
-
-            for (let p = 0; p < frustum.points.length; p++) {
-                const projectedPoint = frustum.points[p][axis] - this.min[axis];
-
-                projMin = Math.min(projMin, projectedPoint);
-                projMax = Math.max(projMax, projectedPoint);
-            }
-
-            if (projMax < 0 || projMin > this.max[axis] - this.min[axis])
-                return 0;
-        }
-
-        return 1;
-    }
-}
-export {
-    Aabb,
-    Frustum
-};

package/src/util/resolve_tokens.js

@@ -1,16 +0,0 @@
-// @flow
-export default resolveTokens;
-
-/**
- * Replace tokens in a string template with values in an object
- *
- * @param properties a key/value relationship between tokens and replacements
- * @param text the template string
- * @returns the template with tokens replaced
- * @private
- */
-function resolveTokens(properties: {+[string]: mixed}, text: string): string {
-    return text.replace(/{([^{}]+)}/g, (match, key: string) => {
-        return key in properties ? String(properties[key]) : '';
-    });
-}

package/src/util/script_detection.js

@@ -1,328 +0,0 @@
-// @flow
-
-/* eslint-disable new-cap */
-
-import isChar from './is_char_in_unicode_block';
-
-export function allowsIdeographicBreaking(chars: string) {
-    for (const char of chars) {
-        if (!charAllowsIdeographicBreaking(char.charCodeAt(0))) return false;
-    }
-    return true;
-}
-
-export function allowsVerticalWritingMode(chars: string) {
-    for (const char of chars) {
-        if (charHasUprightVerticalOrientation(char.charCodeAt(0))) return true;
-    }
-    return false;
-}
-
-export function allowsLetterSpacing(chars: string) {
-    for (const char of chars) {
-        if (!charAllowsLetterSpacing(char.charCodeAt(0))) return false;
-    }
-    return true;
-}
-
-export function charAllowsLetterSpacing(char: number) {
-    if (isChar['Arabic'](char)) return false;
-    if (isChar['Arabic Supplement'](char)) return false;
-    if (isChar['Arabic Extended-A'](char)) return false;
-    if (isChar['Arabic Presentation Forms-A'](char)) return false;
-    if (isChar['Arabic Presentation Forms-B'](char)) return false;
-
-    return true;
-}
-
-export function charAllowsIdeographicBreaking(char: number) {
-    // Return early for characters outside all ideographic ranges.
-    if (char < 0x2E80) return false;
-
-    if (isChar['Bopomofo Extended'](char)) return true;
-    if (isChar['Bopomofo'](char)) return true;
-    if (isChar['CJK Compatibility Forms'](char)) return true;
-    if (isChar['CJK Compatibility Ideographs'](char)) return true;
-    if (isChar['CJK Compatibility'](char)) return true;
-    if (isChar['CJK Radicals Supplement'](char)) return true;
-    if (isChar['CJK Strokes'](char)) return true;
-    if (isChar['CJK Symbols and Punctuation'](char)) return true;
-    if (isChar['CJK Unified Ideographs Extension A'](char)) return true;
-    if (isChar['CJK Unified Ideographs'](char)) return true;
-    if (isChar['Enclosed CJK Letters and Months'](char)) return true;
-    if (isChar['Halfwidth and Fullwidth Forms'](char)) return true;
-    if (isChar['Hiragana'](char)) return true;
-    if (isChar['Ideographic Description Characters'](char)) return true;
-    if (isChar['Kangxi Radicals'](char)) return true;
-    if (isChar['Katakana Phonetic Extensions'](char)) return true;
-    if (isChar['Katakana'](char)) return true;
-    if (isChar['Vertical Forms'](char)) return true;
-    if (isChar['Yi Radicals'](char)) return true;
-    if (isChar['Yi Syllables'](char)) return true;
-
-    return false;
-}
-
-// The following logic comes from
-// <http://www.unicode.org/Public/12.0.0/ucd/VerticalOrientation.txt>.
-// Keep it synchronized with
-// <http://www.unicode.org/Public/UCD/latest/ucd/VerticalOrientation.txt>.
-// The data file denotes with “U” or “Tu” any codepoint that may be drawn
-// upright in vertical text but does not distinguish between upright and
-// “neutral” characters.
-
-// Blocks in the Unicode supplementary planes are excluded from this module due
-// to <https://github.com/mapbox/mapbox-gl/issues/29>.
-
-/**
- * Returns true if the given Unicode codepoint identifies a character with
- * upright orientation.
- *
- * A character has upright orientation if it is drawn upright (unrotated)
- * whether the line is oriented horizontally or vertically, even if both
- * adjacent characters can be rotated. For example, a Chinese character is
- * always drawn upright. An uprightly oriented character causes an adjacent
- * “neutral” character to be drawn upright as well.
- * @private
- */
-export function charHasUprightVerticalOrientation(char: number) {
-    if (char === 0x02EA /* modifier letter yin departing tone mark */ ||
-        char === 0x02EB /* modifier letter yang departing tone mark */) {
-        return true;
-    }
-
-    // Return early for characters outside all ranges whose characters remain
-    // upright in vertical writing mode.
-    if (char < 0x1100) return false;
-
-    if (isChar['Bopomofo Extended'](char)) return true;
-    if (isChar['Bopomofo'](char)) return true;
-    if (isChar['CJK Compatibility Forms'](char)) {
-        if (!((char >= 0xFE49 /* dashed overline */ && char <= 0xFE4F) /* wavy low line */)) {
-            return true;
-        }
-    }
-    if (isChar['CJK Compatibility Ideographs'](char)) return true;
-    if (isChar['CJK Compatibility'](char)) return true;
-    if (isChar['CJK Radicals Supplement'](char)) return true;
-    if (isChar['CJK Strokes'](char)) return true;
-    if (isChar['CJK Symbols and Punctuation'](char)) {
-        if (!((char >= 0x3008 /* left angle bracket */ && char <= 0x3011) /* right black lenticular bracket */) &&
-            !((char >= 0x3014 /* left tortoise shell bracket */ && char <= 0x301F) /* low double prime quotation mark */) &&
-            char !== 0x3030 /* wavy dash */) {
-            return true;
-        }
-    }
-    if (isChar['CJK Unified Ideographs Extension A'](char)) return true;
-    if (isChar['CJK Unified Ideographs'](char)) return true;
-    if (isChar['Enclosed CJK Letters and Months'](char)) return true;
-    if (isChar['Hangul Compatibility Jamo'](char)) return true;
-    if (isChar['Hangul Jamo Extended-A'](char)) return true;
-    if (isChar['Hangul Jamo Extended-B'](char)) return true;
-    if (isChar['Hangul Jamo'](char)) return true;
-    if (isChar['Hangul Syllables'](char)) return true;
-    if (isChar['Hiragana'](char)) return true;
-    if (isChar['Ideographic Description Characters'](char)) return true;
-    if (isChar['Kanbun'](char)) return true;
-    if (isChar['Kangxi Radicals'](char)) return true;
-    if (isChar['Katakana Phonetic Extensions'](char)) return true;
-    if (isChar['Katakana'](char)) {
-        if (char !== 0x30FC /* katakana-hiragana prolonged sound mark */) {
-            return true;
-        }
-    }
-    if (isChar['Halfwidth and Fullwidth Forms'](char)) {
-        if (char !== 0xFF08 /* fullwidth left parenthesis */ &&
-            char !== 0xFF09 /* fullwidth right parenthesis */ &&
-            char !== 0xFF0D /* fullwidth hyphen-minus */ &&
-            !((char >= 0xFF1A /* fullwidth colon */ && char <= 0xFF1E) /* fullwidth greater-than sign */) &&
-            char !== 0xFF3B /* fullwidth left square bracket */ &&
-            char !== 0xFF3D /* fullwidth right square bracket */ &&
-            char !== 0xFF3F /* fullwidth low line */ &&
-            !(char >= 0xFF5B /* fullwidth left curly bracket */ && char <= 0xFFDF) &&
-            char !== 0xFFE3 /* fullwidth macron */ &&
-            !(char >= 0xFFE8 /* halfwidth forms light vertical */ && char <= 0xFFEF)) {
-            return true;
-        }
-    }
-    if (isChar['Small Form Variants'](char)) {
-        if (!((char >= 0xFE58 /* small em dash */ && char <= 0xFE5E) /* small right tortoise shell bracket */) &&
-            !((char >= 0xFE63 /* small hyphen-minus */ && char <= 0xFE66) /* small equals sign */)) {
-            return true;
-        }
-    }
-    if (isChar['Unified Canadian Aboriginal Syllabics'](char)) return true;
-    if (isChar['Unified Canadian Aboriginal Syllabics Extended'](char)) return true;
-    if (isChar['Vertical Forms'](char)) return true;
-    if (isChar['Yijing Hexagram Symbols'](char)) return true;
-    if (isChar['Yi Syllables'](char)) return true;
-    if (isChar['Yi Radicals'](char)) return true;
-
-    return false;
-}
-
-/**
- * Returns true if the given Unicode codepoint identifies a character with
- * neutral orientation.
- *
- * A character has neutral orientation if it may be drawn rotated or unrotated
- * when the line is oriented vertically, depending on the orientation of the
- * adjacent characters. For example, along a verticlly oriented line, the vulgar
- * fraction ½ is drawn upright among Chinese characters but rotated among Latin
- * letters. A neutrally oriented character does not influence whether an
- * adjacent character is drawn upright or rotated.
- * @private
- */
-export function charHasNeutralVerticalOrientation(char: number) {
-    if (isChar['Latin-1 Supplement'](char)) {
-        if (char === 0x00A7 /* section sign */ ||
-            char === 0x00A9 /* copyright sign */ ||
-            char === 0x00AE /* registered sign */ ||
-            char === 0x00B1 /* plus-minus sign */ ||
-            char === 0x00BC /* vulgar fraction one quarter */ ||
-            char === 0x00BD /* vulgar fraction one half */ ||
-            char === 0x00BE /* vulgar fraction three quarters */ ||
-            char === 0x00D7 /* multiplication sign */ ||
-            char === 0x00F7 /* division sign */) {
-            return true;
-        }
-    }
-    if (isChar['General Punctuation'](char)) {
-        if (char === 0x2016 /* double vertical line */ ||
-            char === 0x2020 /* dagger */ ||
-            char === 0x2021 /* double dagger */ ||
-            char === 0x2030 /* per mille sign */ ||
-            char === 0x2031 /* per ten thousand sign */ ||
-            char === 0x203B /* reference mark */ ||
-            char === 0x203C /* double exclamation mark */ ||
-            char === 0x2042 /* asterism */ ||
-            char === 0x2047 /* double question mark */ ||
-            char === 0x2048 /* question exclamation mark */ ||
-            char === 0x2049 /* exclamation question mark */ ||
-            char === 0x2051 /* two asterisks aligned vertically */) {
-            return true;
-        }
-    }
-    if (isChar['Letterlike Symbols'](char)) return true;
-    if (isChar['Number Forms'](char)) return true;
-    if (isChar['Miscellaneous Technical'](char)) {
-        if ((char >= 0x2300 /* diameter sign */ && char <= 0x2307 /* wavy line */) ||
-            (char >= 0x230C /* bottom right crop */ && char <= 0x231F /* bottom right corner */) ||
-            (char >= 0x2324 /* up arrowhead between two horizontal bars */ && char <= 0x2328 /* keyboard */) ||
-            char === 0x232B /* erase to the left */ ||
-            (char >= 0x237D /* shouldered open box */ && char <= 0x239A /* clear screen symbol */) ||
-            (char >= 0x23BE /* dentistry symbol light vertical and top right */ && char <= 0x23CD /* square foot */) ||
-            char === 0x23CF /* eject symbol */ ||
-            (char >= 0x23D1 /* metrical breve */ && char <= 0x23DB /* fuse */) ||
-            (char >= 0x23E2 /* white trapezium */ && char <= 0x23FF)) {
-            return true;
-        }
-    }
-    if (isChar['Control Pictures'](char) && char !== 0x2423 /* open box */) return true;
-    if (isChar['Optical Character Recognition'](char)) return true;
-    if (isChar['Enclosed Alphanumerics'](char)) return true;
-    if (isChar['Geometric Shapes'](char)) return true;
-    if (isChar['Miscellaneous Symbols'](char)) {
-        if (!((char >= 0x261A /* black left pointing index */ && char <= 0x261F) /* white down pointing index */)) {
-            return true;
-        }
-    }
-    if (isChar['Miscellaneous Symbols and Arrows'](char)) {
-        if ((char >= 0x2B12 /* square with top half black */ && char <= 0x2B2F /* white vertical ellipse */) ||
-            (char >= 0x2B50 /* white medium star */ && char <= 0x2B59 /* heavy circled saltire */) ||
-            (char >= 0x2BB8 /* upwards white arrow from bar with horizontal bar */ && char <= 0x2BEB)) {
-            return true;
-        }
-    }
-    if (isChar['CJK Symbols and Punctuation'](char)) return true;
-    if (isChar['Katakana'](char)) return true;
-    if (isChar['Private Use Area'](char)) return true;
-    if (isChar['CJK Compatibility Forms'](char)) return true;
-    if (isChar['Small Form Variants'](char)) return true;
-    if (isChar['Halfwidth and Fullwidth Forms'](char)) return true;
-
-    if (char === 0x221E /* infinity */ ||
-        char === 0x2234 /* therefore */ ||
-        char === 0x2235 /* because */ ||
-        (char >= 0x2700 /* black safety scissors */ && char <= 0x2767 /* rotated floral heart bullet */) ||
-        (char >= 0x2776 /* dingbat negative circled digit one */ && char <= 0x2793 /* dingbat negative circled sans-serif number ten */) ||
-        char === 0xFFFC /* object replacement character */ ||
-        char === 0xFFFD /* replacement character */) {
-        return true;
-    }
-
-    return false;
-}
-
-/**
- * Returns true if the given Unicode codepoint identifies a character with
- * rotated orientation.
- *
- * A character has rotated orientation if it is drawn rotated when the line is
- * oriented vertically, even if both adjacent characters are upright. For
- * example, a Latin letter is drawn rotated along a vertical line. A rotated
- * character causes an adjacent “neutral” character to be drawn rotated as well.
- * @private
- */
-export function charHasRotatedVerticalOrientation(char: number) {
-    return !(charHasUprightVerticalOrientation(char) ||
-             charHasNeutralVerticalOrientation(char));
-}
-
-export function charInComplexShapingScript(char: number) {
-    return isChar['Arabic'](char) ||
-           isChar['Arabic Supplement'](char) ||
-           isChar['Arabic Extended-A'](char) ||
-           isChar['Arabic Presentation Forms-A'](char) ||
-           isChar['Arabic Presentation Forms-B'](char);
-}
-
-export function charInRTLScript(char: number) {
-    // Main blocks for Hebrew, Arabic, Thaana and other RTL scripts
-    return (char >= 0x0590 && char <= 0x08FF) ||
-        isChar['Arabic Presentation Forms-A'](char) ||
-        isChar['Arabic Presentation Forms-B'](char);
-}
-
-export function charInSupportedScript(char: number, canRenderRTL: boolean) {
-    // This is a rough heuristic: whether we "can render" a script
-    // actually depends on the properties of the font being used
-    // and whether differences from the ideal rendering are considered
-    // semantically significant.
-
-    // Even in Latin script, we "can't render" combinations such as the fi
-    // ligature, but we don't consider that semantically significant.
-    if (!canRenderRTL && charInRTLScript(char)) {
-        return false;
-    }
-    if ((char >= 0x0900 && char <= 0x0DFF) ||
-        // Main blocks for Indic scripts and Sinhala
-        (char >= 0x0F00 && char <= 0x109F) ||
-        // Main blocks for Tibetan and Myanmar
-        isChar['Khmer'](char)) {
-        // These blocks cover common scripts that require
-        // complex text shaping, based on unicode script metadata:
-        // http://www.unicode.org/repos/cldr/trunk/common/properties/scriptMetadata.txt
-        // where "Web Rank <= 32" "Shaping Required = YES"
-        return false;
-    }
-    return true;
-}
-
-export function stringContainsRTLText(chars: string): boolean {
-    for (const char of chars) {
-        if (charInRTLScript(char.charCodeAt(0))) {
-            return true;
-        }
-    }
-    return false;
-}
-
-export function isStringInSupportedScript(chars: string, canRenderRTL: boolean) {
-    for (const char of chars) {
-        if (!charInSupportedScript(char.charCodeAt(0), canRenderRTL)) {
-            return false;
-        }
-    }
-    return true;
-}

package/src/util/sku_token.js

@@ -1,42 +0,0 @@
-// @flow
-
-/***** START WARNING - IF YOU USE THIS CODE WITH MAPBOX MAPPING APIS, REMOVAL OR
-* MODIFICATION OF THE FOLLOWING CODE VIOLATES THE MAPBOX TERMS OF SERVICE  ******
-* The following code is used to access Mapbox's Mapping APIs. Removal or modification
-* of this code when used with Mapbox's Mapping APIs can result in higher fees and/or
-* termination of your account with Mapbox.
-*
-* Under the Mapbox Terms of Service, you may not use this code to access Mapbox
-* Mapping APIs other than through Mapbox SDKs.
-*
-* The Mapping APIs documentation is available at https://docs.mapbox.com/api/maps/#maps
-* and the Mapbox Terms of Service are available at https://www.mapbox.com/tos/
-******************************************************************************/
-
-type SkuTokenObject = {|
-    token: string,
-    tokenExpiresAt: number
-|};
-
-const SKU_ID = '01';
-
-function createSkuToken(): SkuTokenObject {
-    // SKU_ID and TOKEN_VERSION are specified by an internal schema and should not change
-    const TOKEN_VERSION = '1';
-    const base62chars = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    // sessionRandomizer is a randomized 10-digit base-62 number
-    let sessionRandomizer = '';
-    for (let i = 0; i < 10; i++) {
-        sessionRandomizer += base62chars[Math.floor(Math.random() * 62)];
-    }
-    const expiration = 12 * 60 * 60 * 1000; // 12 hours
-    const token = [TOKEN_VERSION, SKU_ID, sessionRandomizer].join('');
-    const tokenExpiresAt = Date.now() + expiration;
-
-    return {token, tokenExpiresAt};
-}
-
-export {createSkuToken, SKU_ID};
-
-/***** END WARNING - REMOVAL OR MODIFICATION OF THE
-PRECEDING CODE VIOLATES THE MAPBOX TERMS OF SERVICE  ******/

package/src/util/smart_wrap.js

@@ -1,55 +0,0 @@
-// @flow
-
-import LngLat from '../geo/lng_lat';
-
-import type Point from '@mapbox/point-geometry';
-import type Transform from '../geo/transform';
-
-/**
- * Given a LngLat, prior projected position, and a transform, return a new LngLat shifted
- * n × 360° east or west for some n ≥ 0 such that:
- *
- * * the projected location of the result is on screen, if possible, and secondarily:
- * * the difference between the projected location of the result and the prior position
- *   is minimized.
- *
- * The object is to preserve perceived object constancy for Popups and Markers as much as
- * possible; they should avoid shifting large distances across the screen, even when the
- * map center changes by ±360° due to automatic wrapping, and when about to go off screen,
- * should wrap just enough to avoid doing so.
- *
- * @private
- */
-export default function(lngLat: LngLat, priorPos: ?Point, transform: Transform): LngLat {
-    lngLat = new LngLat(lngLat.lng, lngLat.lat);
-
-    // First, try shifting one world in either direction, and see if either is closer to the
-    // prior position. This preserves object constancy when the map center is auto-wrapped
-    // during animations.
-    if (priorPos) {
-        const left  = new LngLat(lngLat.lng - 360, lngLat.lat);
-        const right = new LngLat(lngLat.lng + 360, lngLat.lat);
-        const delta = transform.locationPoint(lngLat).distSqr(priorPos);
-        if (transform.locationPoint(left).distSqr(priorPos) < delta) {
-            lngLat = left;
-        } else if (transform.locationPoint(right).distSqr(priorPos) < delta) {
-            lngLat = right;
-        }
-    }
-
-    // Second, wrap toward the center until the new position is on screen, or we can't get
-    // any closer.
-    while (Math.abs(lngLat.lng - transform.center.lng) > 180) {
-        const pos = transform.locationPoint(lngLat);
-        if (pos.x >= 0 && pos.y >= 0 && pos.x <= transform.width && pos.y <= transform.height) {
-            break;
-        }
-        if (lngLat.lng > transform.center.lng) {
-            lngLat.lng -= 360;
-        } else {
-            lngLat.lng += 360;
-        }
-    }
-
-    return lngLat;
-}