@scoova/mgl 1.0.0

package/src/geo/lng_lat_bounds.test.ts

@@ -0,0 +1,357 @@
+import {LngLat} from './lng_lat';
+import {LngLatBounds} from './lng_lat_bounds';
+
+describe('LngLatBounds', () => {
+    test('#constructor', () => {
+        const sw = new LngLat(0, 0);
+        const ne = new LngLat(-10, 10);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(bounds.getSouth()).toBe(0);
+        expect(bounds.getWest()).toBe(0);
+        expect(bounds.getNorth()).toBe(10);
+        expect(bounds.getEast()).toBe(-10);
+    });
+
+    test('#constructor across dateline', () => {
+        const sw = new LngLat(170, 0);
+        const ne = new LngLat(-170, 10);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(bounds.getSouth()).toBe(0);
+        expect(bounds.getWest()).toBe(170);
+        expect(bounds.getNorth()).toBe(10);
+        expect(bounds.getEast()).toBe(-170);
+    });
+
+    test('#constructor across pole', () => {
+        const sw = new LngLat(0, 85);
+        const ne = new LngLat(-10, -85);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(bounds.getSouth()).toBe(85);
+        expect(bounds.getWest()).toBe(0);
+        expect(bounds.getNorth()).toBe(-85);
+        expect(bounds.getEast()).toBe(-10);
+    });
+
+    test('#constructor no args', () => {
+        const bounds = new LngLatBounds();
+        const t1 = () => {
+            bounds.getCenter();
+        };
+        expect(t1).toThrow();
+    });
+
+    test('#extend with coordinate', () => {
+        const bounds = new LngLatBounds([0, 0], [10, 10]);
+        bounds.extend([-10, -10]);
+
+        expect(bounds.getSouth()).toBe(-10);
+        expect(bounds.getWest()).toBe(-10);
+        expect(bounds.getNorth()).toBe(10);
+        expect(bounds.getEast()).toBe(10);
+
+        bounds.extend(new LngLat(-15, -15));
+
+        expect(bounds.getSouth()).toBe(-15);
+        expect(bounds.getWest()).toBe(-15);
+        expect(bounds.getNorth()).toBe(10);
+        expect(bounds.getEast()).toBe(10);
+
+        bounds.extend([-80, -80, 80, 80]);
+
+        expect(bounds.getSouth()).toBe(-80);
+        expect(bounds.getWest()).toBe(-80);
+        expect(bounds.getNorth()).toBe(80);
+        expect(bounds.getEast()).toBe(80);
+
+        bounds.extend({lng: -90, lat: -90});
+
+        expect(bounds.getSouth()).toBe(-90);
+        expect(bounds.getWest()).toBe(-90);
+        expect(bounds.getNorth()).toBe(80);
+        expect(bounds.getEast()).toBe(80);
+
+        bounds.extend({lon: 90, lat: 90});
+
+        expect(bounds.getSouth()).toBe(-90);
+        expect(bounds.getWest()).toBe(-90);
+        expect(bounds.getNorth()).toBe(90);
+        expect(bounds.getEast()).toBe(90);
+    });
+
+    test('#extend with bounds', () => {
+        const bounds1 = new LngLatBounds([0, 0], [10, 10]);
+        const bounds2 = new LngLatBounds([-10, -10], [10, 10]);
+
+        bounds1.extend(bounds2);
+
+        expect(bounds1.getSouth()).toBe(-10);
+        expect(bounds1.getWest()).toBe(-10);
+        expect(bounds1.getNorth()).toBe(10);
+        expect(bounds1.getEast()).toBe(10);
+
+        const bounds4 = new LngLatBounds([-20, -20, 20, 20]);
+        bounds1.extend(bounds4);
+
+        expect(bounds1.getSouth()).toBe(-20);
+        expect(bounds1.getWest()).toBe(-20);
+        expect(bounds1.getNorth()).toBe(20);
+        expect(bounds1.getEast()).toBe(20);
+
+        const bounds5 = new LngLatBounds();
+        bounds1.extend(bounds5);
+
+        expect(bounds1.getSouth()).toBe(-20);
+        expect(bounds1.getWest()).toBe(-20);
+        expect(bounds1.getNorth()).toBe(20);
+        expect(bounds1.getEast()).toBe(20);
+    });
+
+    test('#extend with null', () => {
+        const bounds = new LngLatBounds([0, 0], [10, 10]);
+
+        bounds.extend(null);
+
+        expect(bounds.getSouth()).toBe(0);
+        expect(bounds.getWest()).toBe(0);
+        expect(bounds.getNorth()).toBe(10);
+        expect(bounds.getEast()).toBe(10);
+    });
+
+    test('#extend undefined bounding box', () => {
+        const bounds1 = new LngLatBounds(undefined, undefined);
+        const bounds2 = new LngLatBounds([-10, -10], [10, 10]);
+
+        bounds1.extend(bounds2);
+
+        expect(bounds1.getSouth()).toBe(-10);
+        expect(bounds1.getWest()).toBe(-10);
+        expect(bounds1.getNorth()).toBe(10);
+        expect(bounds1.getEast()).toBe(10);
+    });
+
+    test('#extend same LngLat instance', () => {
+        const point = new LngLat(0, 0);
+        const bounds = new LngLatBounds(point, point);
+
+        bounds.extend(new LngLat(15, 15));
+
+        expect(bounds.getSouth()).toBe(0);
+        expect(bounds.getWest()).toBe(0);
+        expect(bounds.getNorth()).toBe(15);
+        expect(bounds.getEast()).toBe(15);
+    });
+
+    test('accessors', () => {
+        const sw = new LngLat(0, 0);
+        const ne = new LngLat(-10, -20);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(bounds.getCenter()).toEqual(new LngLat(-5, -10));
+        expect(bounds.getSouth()).toBe(0);
+        expect(bounds.getWest()).toBe(0);
+        expect(bounds.getNorth()).toBe(-20);
+        expect(bounds.getEast()).toBe(-10);
+        expect(bounds.getSouthWest()).toEqual(new LngLat(0, 0));
+        expect(bounds.getSouthEast()).toEqual(new LngLat(-10, 0));
+        expect(bounds.getNorthEast()).toEqual(new LngLat(-10, -20));
+        expect(bounds.getNorthWest()).toEqual(new LngLat(0, -20));
+    });
+
+    test('#convert', () => {
+        const sw = new LngLat(0, 0);
+        const ne = new LngLat(-10, 10);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(LngLatBounds.convert(undefined)).toBeUndefined();
+        expect(LngLatBounds.convert(bounds)).toEqual(bounds);
+        expect(LngLatBounds.convert([sw, ne])).toEqual(bounds);
+        expect(
+            LngLatBounds.convert([bounds.getWest(), bounds.getSouth(), bounds.getEast(), bounds.getNorth()])
+        ).toEqual(bounds);
+    });
+
+    test('#toArray', () => {
+        const llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+        expect(llb.toArray()).toEqual([[-73.9876, 40.7661], [-73.9397, 40.8002]]);
+    });
+
+    test('#toString', () => {
+        const llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+        expect(llb.toString()).toBe('LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))');
+    });
+
+    test('#isEmpty', () => {
+        const nullBounds = new LngLatBounds();
+        expect(nullBounds.isEmpty()).toBe(true);
+
+        const sw = new LngLat(0, 0);
+        const ne = new LngLat(-10, 10);
+        const bounds = new LngLatBounds(sw, ne);
+        expect(bounds.isEmpty()).toBe(false);
+    });
+
+    test('#fromLngLat', () => {
+        const center0 = new LngLat(0, 0);
+        const center1 = new LngLat(-73.9749, 40.7736);
+
+        const center0Radius10 = LngLatBounds.fromLngLat(center0, 10);
+        const center1Radius10 = LngLatBounds.fromLngLat(center1, 10);
+        const center1Radius0 = LngLatBounds.fromLngLat(center1);
+
+        expect(center0Radius10.toArray()).toEqual(
+            [[-0.00008983152770714982, -0.00008983152770714982], [0.00008983152770714982, 0.00008983152770714982]]
+        );
+        expect(center1Radius10.toArray()).toEqual(
+            [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
+        );
+        expect(center1Radius0.toArray()).toEqual([[-73.9749, 40.7736], [-73.9749, 40.7736]]);
+    });
+
+    describe('LngLatBounds adjustAntiMeridian tests', () => {
+        test('kenya', () => {
+            const sw = new LngLat(32.958984, -5.353521);
+            const ne = new LngLat(43.50585, 5.615985);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-5.353521);
+            expect(bounds.getWest()).toBe(32.958984);
+            expect(bounds.getNorth()).toBe(5.615985);
+            expect(bounds.getEast()).toBe(43.50585);
+        });
+
+        test('normal cross (crossing antimeridian)', () => {
+            const sw = new LngLat(170, 0);
+            const ne = new LngLat(-170, 10);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(0);
+            expect(bounds.getWest()).toBe(170);
+            expect(bounds.getNorth()).toBe(10);
+            expect(bounds.getEast()).toBe(190);
+        });
+
+        test('exactly meridian (crossing antimeridian)', () => {
+            const sw = new LngLat(180, -20);
+            const ne = new LngLat(-180, 20);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-20);
+            expect(bounds.getWest()).toBe(180);
+            expect(bounds.getNorth()).toBe(20);
+            expect(bounds.getEast()).toBe(180);
+        });
+
+        test('small cross (crossing antimeridian)', () => {
+            const sw = new LngLat(179, -5);
+            const ne = new LngLat(-179, 5);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-5);
+            expect(bounds.getWest()).toBe(179);
+            expect(bounds.getNorth()).toBe(5);
+            expect(bounds.getEast()).toBe(181);
+        });
+
+        test('large cross (crossing antimeridian)', () => {
+            const sw = new LngLat(100, -30);
+            const ne = new LngLat(-100, 30);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-30);
+            expect(bounds.getWest()).toBe(100);
+            expect(bounds.getNorth()).toBe(30);
+            expect(bounds.getEast()).toBe(260);
+        });
+
+        test('reverse cross (crossing antimeridian)', () => {
+            const sw = new LngLat(-170, 0);
+            const ne = new LngLat(170, 10);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(0);
+            expect(bounds.getWest()).toBe(-170);
+            expect(bounds.getNorth()).toBe(10);
+            expect(bounds.getEast()).toBe(170);
+        });
+
+        test('reverse not cross', () => {
+            const sw = new LngLat(150, 0);
+            const ne = new LngLat(170, 10);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(0);
+            expect(bounds.getWest()).toBe(150);
+            expect(bounds.getNorth()).toBe(10);
+            expect(bounds.getEast()).toBe(170);
+        });
+
+        test('same longitude', () => {
+            const sw = new LngLat(175, -10);
+            const ne = new LngLat(175, 10);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-10);
+            expect(bounds.getWest()).toBe(175);
+            expect(bounds.getNorth()).toBe(10);
+            expect(bounds.getEast()).toBe(175);
+        });
+
+        test('full world', () => {
+            const sw = new LngLat(-180, -90);
+            const ne = new LngLat(180, 90);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-90);
+            expect(bounds.getWest()).toBe(-180);
+            expect(bounds.getNorth()).toBe(90);
+            expect(bounds.getEast()).toBe(180);
+        });
+
+        test('across pole', () => {
+            const sw = new LngLat(0, 85);
+            const ne = new LngLat(-10, -85);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(85);
+            expect(bounds.getWest()).toBe(0);
+            expect(bounds.getNorth()).toBe(-85);
+            expect(bounds.getEast()).toBe(350);
+        });
+
+        test('across pole reverse', () => {
+            const sw = new LngLat(-10, -85);
+            const ne = new LngLat(0, 85);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(-85);
+            expect(bounds.getWest()).toBe(-10);
+            expect(bounds.getNorth()).toBe(85);
+            expect(bounds.getEast()).toBe(0);
+        });
+
+        test('across dateline', () => {
+            const sw = new LngLat(170, 0);
+            const ne = new LngLat(-170, 10);
+            const bounds = new LngLatBounds(sw, ne).adjustAntiMeridian();
+            expect(bounds.getSouth()).toBe(0);
+            expect(bounds.getWest()).toBe(170);
+            expect(bounds.getNorth()).toBe(10);
+            expect(bounds.getEast()).toBe(190);
+        });
+    });
+
+    describe('contains', () => {
+        describe('point', () => {
+            test('point is in bounds', () => {
+                const llb = new LngLatBounds([-1, -1], [1, 1]);
+                const ll = {lng: 0, lat: 0};
+                expect(llb.contains(ll)).toBeTruthy();
+            });
+
+            test('point is not in bounds', () => {
+                const llb = new LngLatBounds([-1, -1], [1, 1]);
+                const ll = {lng: 3, lat: 3};
+                expect(llb.contains(ll)).toBeFalsy();
+            });
+
+            test('point is in bounds that spans dateline', () => {
+                const llb = new LngLatBounds([190, -10], [170, 10]);
+                const ll = {lng: 180, lat: 0};
+                expect(llb.contains(ll)).toBeTruthy();
+            });
+
+            test('point is not in bounds that spans dateline', () => {
+                const llb = new LngLatBounds([190, -10], [170, 10]);
+                const ll = {lng: 0, lat: 0};
+                expect(llb.contains(ll)).toBeFalsy();
+            });
+        });
+    });
+});

package/src/geo/lng_lat_bounds.ts

@@ -0,0 +1,356 @@
+import {LngLat} from './lng_lat';
+import type {LngLatLike} from './lng_lat';
+
+/**
+ * A {@link LngLatBounds} object, an array of {@link LngLatLike} objects in [sw, ne] order,
+ * or an array of numbers in [west, south, east, north] order.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let v1 = new LngLatBounds(
+ *   new LngLat(-73.9876, 40.7661),
+ *   new LngLat(-73.9397, 40.8002)
+ * );
+ * let v2 = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002])
+ * let v3 = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
+ * ```
+ */
+export type LngLatBoundsLike = LngLatBounds | [LngLatLike, LngLatLike] | [number, number, number, number];
+
+/**
+ * A `LngLatBounds` object represents a geographical bounding box,
+ * defined by its southwest and northeast points in longitude and latitude.
+ *
+ * If no arguments are provided to the constructor, a `null` bounding box is created.
+ *
+ * Note that any Mapbox GL method that accepts a `LngLatBounds` object as an argument or option
+ * can also accept an `Array` of two {@link LngLatLike} constructs and will perform an implicit conversion.
+ * This flexible type is documented as {@link LngLatBoundsLike}.
+ *
+ * @group Geography and Geometry
+ *
+ * @example
+ * ```ts
+ * let sw = new LngLat(-73.9876, 40.7661);
+ * let ne = new LngLat(-73.9397, 40.8002);
+ * let llb = new LngLatBounds(sw, ne);
+ * ```
+ */
+export class LngLatBounds {
+    _ne: LngLat;
+    _sw: LngLat;
+
+    /**
+     * @param sw - The southwest corner of the bounding box.
+     * OR array of 4 numbers in the order of  west, south, east, north
+     * OR array of 2 LngLatLike: [sw,ne]
+     * @param ne - The northeast corner of the bounding box.
+     * @example
+     * ```ts
+     * let sw = new LngLat(-73.9876, 40.7661);
+     * let ne = new LngLat(-73.9397, 40.8002);
+     * let llb = new LngLatBounds(sw, ne);
+     * ```
+     * OR
+     * ```ts
+     * let llb = new LngLatBounds([-73.9876, 40.7661, -73.9397, 40.8002]);
+     * ```
+     * OR
+     * ```ts
+     * let llb = new LngLatBounds([sw, ne]);
+     * ```
+     */
+    constructor(sw?: LngLatLike | [number, number, number, number] | [LngLatLike, LngLatLike], ne?: LngLatLike) {
+        if (!sw) {
+            // noop
+        } else if (ne) {
+            this.setSouthWest(<LngLatLike>sw).setNorthEast(ne);
+        } else if (Array.isArray(sw)) {
+            if (sw.length === 4) {
+            // 4 element array: west, south, east, north
+                this.setSouthWest([sw[0], sw[1]]).setNorthEast([sw[2], sw[3]]);
+            } else {
+                this.setSouthWest(sw[0] as LngLatLike).setNorthEast(sw[1] as LngLatLike);
+            }
+        }
+    }
+
+    /**
+     * Set the northeast corner of the bounding box
+     *
+     * @param ne - a {@link LngLatLike} object describing the northeast corner of the bounding box.
+     */
+    setNorthEast(ne: LngLatLike): this {
+        this._ne = ne instanceof LngLat ? new LngLat(ne.lng, ne.lat) : LngLat.convert(ne);
+        return this;
+    }
+
+    /**
+     * Set the southwest corner of the bounding box
+     *
+     * @param sw - a {@link LngLatLike} object describing the southwest corner of the bounding box.
+     */
+    setSouthWest(sw: LngLatLike): this {
+        this._sw = sw instanceof LngLat ? new LngLat(sw.lng, sw.lat) : LngLat.convert(sw);
+        return this;
+    }
+
+    /**
+     * Extend the bounds to include a given LngLatLike or LngLatBoundsLike.
+     *
+     * @param obj - object to extend to
+     */
+    extend(obj: LngLatLike | LngLatBoundsLike): this {
+        const sw = this._sw,
+            ne = this._ne;
+        let sw2, ne2;
+
+        if (obj instanceof LngLat) {
+            sw2 = obj;
+            ne2 = obj;
+
+        } else if (obj instanceof LngLatBounds) {
+            sw2 = obj._sw;
+            ne2 = obj._ne;
+
+            if (!sw2 || !ne2) return this;
+
+        } else {
+            if (Array.isArray(obj)) {
+                if (obj.length === 4 || (obj as any[]).every(Array.isArray)) {
+                    const lngLatBoundsObj = (obj as any as LngLatBoundsLike);
+                    return this.extend(LngLatBounds.convert(lngLatBoundsObj));
+                } else {
+                    const lngLatObj = (obj as any as LngLatLike);
+                    return this.extend(LngLat.convert(lngLatObj));
+                }
+
+            } else if (obj && ('lng' in obj || 'lon' in obj) && 'lat' in obj) {
+                return this.extend(LngLat.convert(obj));
+            }
+
+            return this;
+        }
+
+        if (!sw && !ne) {
+            this._sw = new LngLat(sw2.lng, sw2.lat);
+            this._ne = new LngLat(ne2.lng, ne2.lat);
+
+        } else {
+            sw.lng = Math.min(sw2.lng, sw.lng);
+            sw.lat = Math.min(sw2.lat, sw.lat);
+            ne.lng = Math.max(ne2.lng, ne.lng);
+            ne.lat = Math.max(ne2.lat, ne.lat);
+        }
+
+        return this;
+    }
+
+    /**
+     * Returns the geographical coordinate equidistant from the bounding box's corners.
+     *
+     * @returns The bounding box's center.
+     * @example
+     * ```ts
+     * let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.getCenter(); // = LngLat {lng: -73.96365, lat: 40.78315}
+     * ```
+     */
+    getCenter(): LngLat {
+        return new LngLat((this._sw.lng + this._ne.lng) / 2, (this._sw.lat + this._ne.lat) / 2);
+    }
+
+    /**
+     * Returns the southwest corner of the bounding box.
+     *
+     * @returns The southwest corner of the bounding box.
+     */
+    getSouthWest(): LngLat { return this._sw; }
+
+    /**
+     * Returns the northeast corner of the bounding box.
+     *
+     * @returns The northeast corner of the bounding box.
+     */
+    getNorthEast(): LngLat { return this._ne; }
+
+    /**
+     * Returns the northwest corner of the bounding box.
+     *
+     * @returns The northwest corner of the bounding box.
+     */
+    getNorthWest(): LngLat { return new LngLat(this.getWest(), this.getNorth()); }
+
+    /**
+     * Returns the southeast corner of the bounding box.
+     *
+     * @returns The southeast corner of the bounding box.
+     */
+    getSouthEast(): LngLat { return new LngLat(this.getEast(), this.getSouth()); }
+
+    /**
+     * Returns the west edge of the bounding box.
+     *
+     * @returns The west edge of the bounding box.
+     */
+    getWest(): number { return this._sw.lng; }
+
+    /**
+     * Returns the south edge of the bounding box.
+     *
+     * @returns The south edge of the bounding box.
+     */
+    getSouth(): number { return this._sw.lat; }
+
+    /**
+     * Returns the east edge of the bounding box.
+     *
+     * @returns The east edge of the bounding box.
+     */
+    getEast(): number { return this._ne.lng; }
+
+    /**
+     * Returns the north edge of the bounding box.
+     *
+     * @returns The north edge of the bounding box.
+     */
+    getNorth(): number { return this._ne.lat; }
+
+    /**
+     * Returns the bounding box represented as an array.
+     *
+     * @returns The bounding box represented as an array, consisting of the
+     * southwest and northeast coordinates of the bounding represented as arrays of numbers.
+     * @example
+     * ```ts
+     * let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.toArray(); // = [[-73.9876, 40.7661], [-73.9397, 40.8002]]
+     * ```
+     */
+    toArray() {
+        return [this._sw.toArray(), this._ne.toArray()];
+    }
+
+    /**
+     * Return the bounding box represented as a string.
+     *
+     * @returns The bounding box represents as a string of the format
+     * `'LngLatBounds(LngLat(lng, lat), LngLat(lng, lat))'`.
+     * @example
+     * ```ts
+     * let llb = new LngLatBounds([-73.9876, 40.7661], [-73.9397, 40.8002]);
+     * llb.toString(); // = "LngLatBounds(LngLat(-73.9876, 40.7661), LngLat(-73.9397, 40.8002))"
+     * ```
+     */
+    toString() {
+        return `LngLatBounds(${this._sw.toString()}, ${this._ne.toString()})`;
+    }
+
+    /**
+     * Check if the bounding box is an empty/`null`-type box.
+     *
+     * @returns True if bounds have been defined, otherwise false.
+     */
+    isEmpty() {
+        return !(this._sw && this._ne);
+    }
+
+    /**
+     * Check if the point is within the bounding box.
+     *
+     * @param lnglat - geographic point to check against.
+     * @returns `true` if the point is within the bounding box.
+     * @example
+     * ```ts
+     * let llb = new LngLatBounds(
+     *   new LngLat(-73.9876, 40.7661),
+     *   new LngLat(-73.9397, 40.8002)
+     * );
+     *
+     * let ll = new LngLat(-73.9567, 40.7789);
+     *
+     * console.log(llb.contains(ll)); // = true
+     * ```
+     */
+    contains(lnglat: LngLatLike) {
+        const {lng, lat} = LngLat.convert(lnglat);
+
+        const containsLatitude = this._sw.lat <= lat && lat <= this._ne.lat;
+        let containsLongitude = this._sw.lng <= lng && lng <= this._ne.lng;
+        if (this._sw.lng > this._ne.lng) { // wrapped coordinates
+            containsLongitude = this._sw.lng >= lng && lng >= this._ne.lng;
+        }
+
+        return containsLatitude && containsLongitude;
+    }
+
+    /**
+     * Converts an array to a `LngLatBounds` object.
+     *
+     * If a `LngLatBounds` object is passed in, the function returns it unchanged.
+     *
+     * Internally, the function calls `LngLat#convert` to convert arrays to `LngLat` values.
+     *
+     * @param input - An array of two coordinates to convert, or a `LngLatBounds` object to return.
+     * @returns A new `LngLatBounds` object, if a conversion occurred, or the original `LngLatBounds` object.
+     * @example
+     * ```ts
+     * let arr = [[-73.9876, 40.7661], [-73.9397, 40.8002]];
+     * let llb = LngLatBounds.convert(arr); // = LngLatBounds {_sw: LngLat {lng: -73.9876, lat: 40.7661}, _ne: LngLat {lng: -73.9397, lat: 40.8002}}
+     * ```
+     */
+    static convert(input: LngLatBoundsLike | null): LngLatBounds {
+        if (input instanceof LngLatBounds) return input;
+        if (!input) return input as null;
+        return new LngLatBounds(input);
+    }
+
+    /**
+     * Returns a `LngLatBounds` from the coordinates extended by a given `radius`. The returned `LngLatBounds` completely contains the `radius`.
+     *
+     * @param center - center coordinates of the new bounds.
+     * @param radius - Distance in meters from the coordinates to extend the bounds.
+     * @returns A new `LngLatBounds` object representing the coordinates extended by the `radius`.
+     * @example
+     * ```ts
+     * let center = new LngLat(-73.9749, 40.7736);
+     * LngLatBounds.fromLngLat(100).toArray(); // = [[-73.97501862141328, 40.77351016847229], [-73.97478137858673, 40.77368983152771]]
+     * ```
+     */
+    static fromLngLat(center: LngLat, radius:number = 0): LngLatBounds {
+        const earthCircumferenceInMetersAtEquator = 40075017;
+        const latAccuracy = 360 * radius / earthCircumferenceInMetersAtEquator,
+            lngAccuracy = latAccuracy / Math.cos((Math.PI / 180) * center.lat);
+
+        return new LngLatBounds(new LngLat(center.lng - lngAccuracy, center.lat - latAccuracy),
+            new LngLat(center.lng + lngAccuracy, center.lat + latAccuracy));
+    }
+
+    /**
+     * Adjusts the given bounds to handle the case where the bounds cross the 180th meridian (antimeridian).
+     *
+     * @returns The adjusted LngLatBounds
+     * @example
+     * ```ts
+     * let bounds = new LngLatBounds([175.813127, -20.157768], [-178. 340903, -15.449124]);
+     * let adjustedBounds = bounds.adjustAntiMeridian();
+     * // adjustedBounds will be: [[175.813127, -20.157768], [181.659097, -15.449124]]
+     * ```
+     */
+    adjustAntiMeridian(): LngLatBounds {
+        const sw = new LngLat(this._sw.lng, this._sw.lat);
+        const ne = new LngLat(this._ne.lng, this._ne.lat);
+
+        if (sw.lng > ne.lng) {
+            return new LngLatBounds(
+                sw,
+                new LngLat(ne.lng + 360, ne.lat)
+            );
+        }
+
+        return new LngLatBounds(sw, ne);
+    }
+
+}