@konfirm/geojson 1.0.0

package/source/Domain/Iterator/SimpleGeometry.ts

@@ -0,0 +1,137 @@
+import { LineString, MultiLineString, MultiPoint, MultiPolygon, Point, Polygon } from "../../main";
+import { Feature } from "../GeoJSON/Feature";
+import { FeatureCollection } from "../GeoJSON/FeatureCollection";
+import { GeoJSON } from "../GeoJSON/GeoJSON";
+import { GeometryCollection } from "../GeoJSON/GeometryCollection";
+
+type SimpleGeometry = Point | LineString | Polygon;
+
+/**
+ * Iterator class to turn any GeoJSON structure into one or more SimpleGeometry (Point | LineString | Polygon) objects
+ *
+ * @export
+ * @class SimpleGeometryIterator
+ */
+export class SimpleGeometryIterator {
+    private readonly inputs: Array<GeoJSON> = [];
+
+    /**
+     *  Creates an instance of SimpleGeometryIterator
+     * 
+     * @param {...[GeoJSON, ...Array<GeoJSON>]} inputs
+     * @memberof SimpleGeometryIterator
+     */
+    constructor(...inputs: [GeoJSON, ...Array<GeoJSON>]) {
+        this.inputs = inputs;
+    }
+
+    /**
+     * Generator yielding all SimpleGeometry objects from the provided GeoJSON structure(s)
+     *
+     * @return {*}  {Iterator<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    *[Symbol.iterator](): Iterator<SimpleGeometry> {
+        for (const input of this.inputs) {
+            for (const simple of this.unwrap(input)) {
+                yield simple;
+            }
+        }
+    }
+
+    /**
+     * unwrap any GeoJSON object into one or more SimpleGeometry object
+     *
+     * @private
+     * @param {GeoJSON} geo
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *unwrap(geo: GeoJSON): Iterable<SimpleGeometry> {
+        geo.type in this
+            ? yield* this[geo.type](geo)
+            : yield geo as SimpleGeometry;
+    }
+
+    /**
+     * Generate the geometries in a GeometryCollection
+     *
+     * @private
+     * @param {GeometryCollection} { geometries }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *GeometryCollection({ geometries }: GeometryCollection): Iterable<SimpleGeometry> {
+        for (const geometry of geometries) {
+            yield* this.unwrap(geometry);
+        }
+    }
+
+    /**
+     * Generate the geometries of the Feature object(s) in a FeatureCollection
+     *
+     * @private
+     * @param {FeatureCollection} { features }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *FeatureCollection({ features }: FeatureCollection): Iterable<SimpleGeometry> {
+        for (const { geometry } of features) {
+            yield* this.unwrap(geometry);
+        }
+    }
+
+    /**
+     * Generate the geometry of a Feature object
+     *
+     * @private
+     * @param {Feature} { geometry }
+     * @return {*}  {Iterable<SimpleGeometry>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *Feature({ geometry }: Feature): Iterable<SimpleGeometry> {
+        yield* this.unwrap(geometry);
+    }
+
+    /**
+     * Generate Point objects from a MultiPoint object
+     *
+     * @private
+     * @param {MultiPoint} multi
+     * @return {*}  {Iterable<Point>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *MultiPoint(multi: MultiPoint): Iterable<Point> {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'Point', coordinates };
+        }
+    }
+
+    /**
+     * Generate LineString objects from a MultiLineString object
+     *
+     * @private
+     * @param {MultiLineString} multi
+     * @return {*}  {Iterable<LineString>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *MultiLineString(multi: MultiLineString): Iterable<LineString> {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'LineString', coordinates };
+        }
+    }
+
+    /**
+     * Generate Polygon objects from a MultiPolygon object
+     *
+     * @private
+     * @param {MultiPolygon} multi
+     * @return {*}  {Iterable<Polygon>}
+     * @memberof SimpleGeometryIterator
+     */
+    private *MultiPolygon(multi: MultiPolygon): Iterable<Polygon> {
+        for (const coordinates of multi.coordinates) {
+            yield { type: 'Polygon', coordinates };
+        }
+    }
+}

package/source/Domain/Utility/Calculate.ts

@@ -0,0 +1,143 @@
+import { Point } from "../GeoJSON/Geometry/Point";
+import { EARTH_RADIUS, EARTH_RADIUS_MAJOR, EARTH_RADIUS_MINOR, EARTH_FLATTENING } from '../Constants';
+
+const D2R = Math.PI / 180;
+const π = Math.PI;
+
+function constrain(value: number, min: number, max: number): number {
+    return Math.max(Math.min(value, max), min);
+}
+
+function squared(n: number): number {
+    return n * n;
+}
+
+function rad(n: number): number {
+    return n * D2R;
+}
+
+const EARTH_RADIUS_MAJOR_SQUARED = squared(EARTH_RADIUS_MAJOR);
+const EARTH_RADIUS_MINOR_SQUARED = squared(EARTH_RADIUS_MINOR);
+const EARTH_RADIUS_FACTOR = (EARTH_RADIUS_MAJOR_SQUARED - EARTH_RADIUS_MINOR_SQUARED) / EARTH_RADIUS_MINOR_SQUARED;
+const EARTH_INVERSE_FLATTENING = 1 / EARTH_FLATTENING;
+
+
+const PointToPoint: { [key: string]: (...positions: [Point['coordinates'], Point['coordinates']]) => number } = {
+    cartesian([λa, φa], [λb, φb]) {
+        return EARTH_RADIUS * rad(Math.sqrt(squared(λb - λa) + squared(φb - φa)));
+    },
+    haversine([λa, φa], [λb, φb]) {
+        //https://www.movable-type.co.uk/scripts/latlong.html
+        const Δ = squared(Math.sin(rad(φb - φa) / 2)) + Math.cos(rad(φa)) * Math.cos(rad(φb)) * squared(Math.sin(rad(λb - λa) / 2));
+
+        return EARTH_RADIUS * Math.atan2(Math.sqrt(Δ), Math.sqrt(1 - Δ)) * 2;
+    },
+    vincenty(...points) {
+        //https://www.movable-type.co.uk/scripts/latlong-vincenty.html
+        const [[λ1, φ1], [λ2, φ2]] = points.map((p) => p.map(rad));
+        const L = λ2 - λ1; // L = difference in longitude, U = reduced latitude, defined by tan U = (1-f)·tanφ.
+        const tanU1 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(φ1), cosU1 = 1 / Math.sqrt((1 + tanU1 * tanU1)), sinU1 = tanU1 * cosU1;
+        const tanU2 = (1 - EARTH_INVERSE_FLATTENING) * Math.tan(φ2), cosU2 = 1 / Math.sqrt((1 + tanU2 * tanU2)), sinU2 = tanU2 * cosU2;
+
+        const antipodal = Math.abs(L) > π / 2 || Math.abs(φ2 - φ1) > π / 2;
+
+        let λ = L;
+        let sinλ = null;
+        let cosλ = null; // λ = difference in longitude on an auxiliary sphere
+        let σ = antipodal ? π : 0;
+        let sinσ = 0;
+        let cosσ = antipodal ? -1 : 1
+        let sinSqσ = null; // σ = angular distance P₁ P₂ on the sphere
+        let cos2σₘ = 1;                      // σₘ = angular distance on the sphere from the equator to the midpoint of the line
+        let cosSqα = 1;                      // α = azimuth of the geodesic at the equator
+        let λʹ = null;
+        let iterations = 0;
+
+        do {
+            sinλ = Math.sin(λ);
+            cosλ = Math.cos(λ);
+            sinSqσ = (cosU2 * sinλ) ** 2 + (cosU1 * sinU2 - sinU1 * cosU2 * cosλ) ** 2;
+            if (Math.abs(sinSqσ) < 1e-24) break;  // co-incident/antipodal points (σ < ≈0.006mm)
+            sinσ = Math.sqrt(sinSqσ);
+            cosσ = sinU1 * sinU2 + cosU1 * cosU2 * cosλ;
+            σ = Math.atan2(sinσ, cosσ);
+            const sinα = cosU1 * cosU2 * sinλ / sinσ;
+            cosSqα = 1 - sinα * sinα;
+            cos2σₘ = (cosSqα != 0) ? (cosσ - 2 * sinU1 * sinU2 / cosSqα) : 0; // on equatorial line cos²α = 0 (§6)
+            const C = EARTH_INVERSE_FLATTENING / 16 * cosSqα * (4 + EARTH_INVERSE_FLATTENING * (4 - 3 * cosSqα));
+            λʹ = λ;
+            λ = L + (1 - C) * EARTH_INVERSE_FLATTENING * sinα * (σ + C * sinσ * (cos2σₘ + C * cosσ * (-1 + 2 * cos2σₘ * cos2σₘ)));
+            // TODO: add tests
+            // const iterationCheck = antipodal ? Math.abs(λ) - π : Math.abs(λ);
+            // if (iterationCheck > π) throw new EvalError('λ > π');
+        } while (Math.abs(λ - λʹ) > 1e-12 && ++iterations < 1000); // TV: 'iterate until negligible change in λ' (≈0.006mm)
+        // TODO: add tests
+        // if (iterations >= 1000) throw new EvalError('Vincenty formula failed to converge');
+
+        const uSq = cosSqα * EARTH_RADIUS_FACTOR;
+        const A = 1 + uSq / 16384 * (4096 + uSq * (-768 + uSq * (320 - 175 * uSq)));
+        const B = uSq / 1024 * (256 + uSq * (-128 + uSq * (74 - 47 * uSq)));
+        const Δσ = B * sinσ * (cos2σₘ + B / 4 * (cosσ * (-1 + 2 * cos2σₘ * cos2σₘ) - B / 6 * cos2σₘ * (-3 + 4 * sinσ * sinσ) * (-3 + 4 * cos2σₘ * cos2σₘ)));
+
+        return EARTH_RADIUS_MINOR * A * (σ - Δσ);
+    },
+};
+
+export type PointToPointCalculation = 'cartesian' | 'haversine' | 'vincenty' | ((a: Point['coordinates'], b: Point['coordinates']) => number);
+
+export function getClosestPointOnLineByPoint(point: Point['coordinates'], line: [Point['coordinates'], Point['coordinates']]): Point['coordinates'] {
+    const [[px, py], [ax, ay], [bx, by]] = [point, ...line];
+    const [abx, aby] = [bx - ax, by - ay];
+    const [apx, apy] = [px - ax, py - ay];
+    const t = constrain((apx * abx + apy * aby) / (abx * abx + aby * aby), 0, 1);
+
+    return t === 0 || t === 1 ? line[t] : [ax + abx * t, ay + aby * t];
+}
+
+export function getDistanceOfPointToPoint(a: Point['coordinates'], b: Point['coordinates'], calculation: PointToPointCalculation): number {
+    const calc = typeof calculation === 'function' ? calculation : PointToPoint[calculation];
+
+    if (typeof calc === 'function') {
+        return calc(a, b);
+    }
+
+    throw new Error(`Not a PointToPoint calculation function ${calculation}`);
+}
+
+export function getDistanceOfPointToLine(point: Point['coordinates'], line: [Point['coordinates'], Point['coordinates']], calculation: PointToPointCalculation): number {
+    return getDistanceOfPointToPoint(point, getClosestPointOnLineByPoint(point, line), calculation);
+}
+
+export function getDistanceOfLineToLine(a: [Point['coordinates'], Point['coordinates']], b: [Point['coordinates'], Point['coordinates']], calculation: PointToPointCalculation): number {
+    return isLinesCrossing(a, b)
+        ? 0
+        : Math.min(...a.map((a) => getDistanceOfPointToLine(a, b, calculation)), ...b.map((b) => getDistanceOfPointToLine(b, a, calculation)));
+}
+
+export function isLinesCrossing(a: [Point['coordinates'], Point['coordinates']], b: [Point['coordinates'], Point['coordinates']]): boolean {
+    const [[a1x, a1y], [a2x, a2y]] = a;
+    const [[b1x, b1y], [b2x, b2y]] = b;
+    const [s1x, s1y, s2x, s2y] = [a2x - a1x, a2y - a1y, b2x - b1x, b2y - b1y];
+    const s = (-s1y * (a1x - b1x) + s1x * (a1y - b1y)) / (-s2x * s1y + s1x * s2y);
+    const t = (s2x * (a1y - b1y) - s2y * (a1x - b1x)) / (-s2x * s1y + s1x * s2y);
+
+    return s >= 0 && s <= 1 && t >= 0 && t <= 1;
+}
+
+export function isPointOnLine(point: Point['coordinates'], line: [Point['coordinates'], Point['coordinates']], threshold: number = 1e-14): boolean {
+    return getDistanceOfPointToLine(point, line, 'cartesian') < threshold;
+}
+
+export function isPointInRing(p: Point['coordinates'], ring: Array<Point['coordinates']>): boolean {
+    const { length } = ring;
+    const odd = ring
+        .reduce((odd, a, i) => {
+            const b = ring[(length + i - 1) % length];
+
+            return (a[1] < p[1] && b[1] >= p[1] || b[1] < p[1] && a[1] >= p[1]) && (a[0] <= p[0] || b[0] <= p[0])
+                ? odd ^ Number(a[0] + (p[1] - a[1]) / (b[1] - a[1]) * (b[0] - a[0]) < p[0])
+                : odd;
+        }, 0);
+
+    return odd !== 0 || ring.slice(1).some((a, index) => isPointOnLine(p, [ring[index], a]));
+}

package/source/Domain/Utility/Distance.ts

@@ -0,0 +1,56 @@
+import { GeoJSON } from '../GeoJSON/GeoJSON';
+import { Point } from '../GeoJSON/Geometry/Point';
+import { LineString } from '../GeoJSON/Geometry/LineString';
+import { Polygon } from '../GeoJSON/Geometry/Polygon';
+import { segments } from './Segments';
+import { SimpleGeometryIterator } from '../Iterator/SimpleGeometry';
+import { IterablePairIterator } from '../Iterator/IterablePair';
+import { getDistanceOfLineToLine, getDistanceOfPointToLine, getDistanceOfPointToPoint, isPointInRing, PointToPointCalculation } from './Calculate';
+
+const geometries = {
+    PointPoint(a: Point['coordinates'], b: Point['coordinates'], calculation: PointToPointCalculation): number {
+        return getDistanceOfPointToPoint(a, b, calculation);
+    },
+    LineStringPoint(a: LineString['coordinates'], b: Point['coordinates'], calculation: PointToPointCalculation): number {
+        return Math.min(...segments(a).map((line) => getDistanceOfPointToLine(b, line, calculation)));
+    },
+    LineStringLineString(a: LineString['coordinates'], b: LineString['coordinates'], calculation: PointToPointCalculation): number {
+        const sa = segments(a);
+        const sb = segments(b);
+
+        return sa.reduce((carry, a) => sb.reduce((carry, b) => carry > 0 ? Math.min(carry, getDistanceOfLineToLine(a, b, calculation)) : carry, carry), Infinity);
+    },
+    PolygonPoint([exterior, ...interior]: Polygon['coordinates'], b: Point['coordinates'], calculation: PointToPointCalculation): number {
+        if (isPointInRing(b, exterior)) {
+            const [excluded] = interior.filter((ring) => isPointInRing(b, ring));
+
+            return excluded ? this.LineStringPoint(excluded, b, calculation) : 0;
+        }
+
+        return this.LineStringPoint(exterior, b, calculation);
+    },
+    PolygonLineString(a: Polygon['coordinates'], b: LineString['coordinates'], calculation: PointToPointCalculation): number {
+        const [exterior, ...interior] = a;
+        const line = segments(b);
+        const ring = b.some((b) => isPointInRing(b, exterior))
+            ? interior.find((a) => b.every((b) => isPointInRing(b, a)))
+            : exterior;
+
+        return ring
+            ? Math.min(...segments(ring).map((a) => Math.min(...line.map((b) => getDistanceOfLineToLine(a, b, calculation)))))
+            : 0;
+    },
+    PolygonPolygon(a: Polygon['coordinates'], b: Polygon['coordinates'], calculation: PointToPointCalculation): number {
+        return Math.min(this.PolygonLineString(a, b[0], calculation), this.PolygonLineString(b, a[0], calculation));
+    },
+};
+
+export function distance(a: GeoJSON, b: GeoJSON, calculation: PointToPointCalculation = 'cartesian'): number {
+    return Math.min(...[...new IterablePairIterator(new SimpleGeometryIterator(a), new SimpleGeometryIterator(b))].map(([a, b]) => {
+        return a.type + b.type in geometries
+            ? geometries[a.type + b.type](a.coordinates, b.coordinates, calculation)
+            : b.type + a.type in geometries
+                ? geometries[b.type + a.type](b.coordinates, a.coordinates, calculation)
+                : Infinity
+    }));
+}

package/source/Domain/Utility/Intersect.ts

@@ -0,0 +1,42 @@
+import { Point } from '../GeoJSON/Geometry/Point';
+import { LineString } from '../GeoJSON/Geometry/LineString';
+import { Polygon } from '../GeoJSON/Geometry/Polygon';
+import { GeoJSON } from '../GeoJSON/GeoJSON';
+import { segments } from './Segments';
+import { isLinesCrossing, isPointInRing, isPointOnLine } from "./Calculate";
+import { SimpleGeometryIterator } from "../Iterator/SimpleGeometry";
+import { IterablePairIterator } from "../Iterator/IterablePair";
+
+const geometries = {
+	PointPoint(a: Point['coordinates'], b: Point['coordinates']): boolean {
+		return a.length >= 2 && b.length >= 2 && a.slice(0, 2).every((v, i) => v === b[i]);
+	},
+	LineStringPoint(a: LineString['coordinates'], b: Point['coordinates']): boolean {
+		return a.some((a) => this.PointPoint(a, b)) || segments(a).some((line) => isPointOnLine(b, line));
+	},
+	LineStringLineString(a: LineString['coordinates'], b: LineString['coordinates']): boolean {
+		const lines = segments(b);
+
+		return segments(a).some((a) => lines.some((b) => isLinesCrossing(a, b)));
+	},
+	PolygonPoint([exterior, ...interior]: Polygon['coordinates'], b: Point['coordinates']): boolean {
+		return (this.LineStringPoint(exterior, b) || isPointInRing(b, exterior)) && (!interior.length || interior.every((ring) => !isPointInRing(b, ring)));
+	},
+	PolygonLineString(a: Polygon['coordinates'], b: LineString['coordinates']): boolean {
+		return a.some((ring) => this.LineStringLineString(ring, b)) || b.some((point) => this.PolygonPoint(a, point));
+	},
+	PolygonPolygon(a: Polygon['coordinates'], b: Polygon['coordinates']): boolean {
+		return b.some((b1) => this.PolygonLineString(a, b1) || b1.some((b2) => this.PolygonPoint(a, b2)))
+			|| a.some((a1) => this.PolygonLineString(b, a1) || a1.some((a2) => this.PolygonPoint(b, a2)))
+	},
+};
+
+export function intersect(a: GeoJSON, b: GeoJSON): boolean {
+	for (const [itA, itB] of new IterablePairIterator(new SimpleGeometryIterator(a), new SimpleGeometryIterator(b))) {
+		if ((itA.type + itB.type in geometries && geometries[itA.type + itB.type](itA.coordinates, itB.coordinates)) || (itB.type + itA.type in geometries && geometries[itB.type + itA.type](itB.coordinates, itA.coordinates))) {
+			return true;
+		}
+	}
+
+	return false;
+}

package/source/Domain/Utility/Numeric.ts

@@ -0,0 +1,8 @@
+export function bounds<T extends number>(a: number, b: number): (value: number) => T {
+	const min = Math.min(a, b);
+	const max = Math.max(a, b);
+	const range = max - min;
+	const mod = (value: number): T => value < min ? mod(value + range) : value > max ? mod(value - range) : <T>value;
+
+	return (value: number): T => mod(value) as T;
+}

package/source/Domain/Utility/Segments.ts

@@ -0,0 +1,5 @@
+import { Point } from '../GeoJSON/Geometry/Point';
+
+export function segments(line: Array<Point['coordinates']>): Array<[Point['coordinates'], Point['coordinates']]> {
+    return line.slice(1).map((point, index) => [line[index], point]);
+}

package/source/Domain/Utility/Winding.ts

@@ -0,0 +1,19 @@
+import { isArrayOfType } from "@konfirm/guard";
+import { isPosition, Position } from "../GeoJSON/Concept/Position";
+
+function winding(positions: Array<Position>): number {
+	return positions.reduce((carry, [x, y], i, a) => {
+		const [nx, ny] = a[(i + 1) % a.length];
+
+		return carry + ((nx - x) * (ny + y));
+	}, 0);
+}
+
+const isPositionArray = isArrayOfType<Array<Position>>(isPosition);
+
+export function isClockwiseWinding<T extends Array<Position>>(value: any): value is T {
+	return isPositionArray(value) && winding(value) <= 0;
+}
+export function isCounterClockwiseWinding<T extends Array<Position>>(value: any): value is T {
+	return isPositionArray(value) && winding(value) >= 0;
+}

package/source/main.ts

@@ -0,0 +1,20 @@
+// intersect and distance functions
+export { intersect } from './Domain/Utility/Intersect';
+export { distance } from './Domain/Utility/Distance';
+
+// SimpleGeometryIterator
+export { SimpleGeometryIterator } from './Domain/Iterator/SimpleGeometry';
+
+// the individual GeoJSON types and type guards
+export { Position, isPosition, isStrictPosition } from './Domain/GeoJSON/Concept/Position';
+export { Point, isPoint, isStrictPoint } from './Domain/GeoJSON/Geometry/Point';
+export { MultiPoint, isMultiPoint, isStrictMultiPoint } from './Domain/GeoJSON/Geometry/MultiPoint';
+export { LineString, isLineString, isStrictLineString } from './Domain/GeoJSON/Geometry/LineString';
+export { MultiLineString, isMultiLineString, isStrictMultiLineString } from './Domain/GeoJSON/Geometry/MultiLineString';
+export { Polygon, isPolygon, isStrictPolygon } from './Domain/GeoJSON/Geometry/Polygon';
+export { MultiPolygon, isMultiPolygon, isStrictMultiPolygon } from './Domain/GeoJSON/Geometry/MultiPolygon';
+export { GeometryCollection, isGeometryCollection, isStrictGeometryCollection } from './Domain/GeoJSON/GeometryCollection';
+export { Geometry, isGeometry, isStrictGeometry } from './Domain/GeoJSON/Geometry';
+export { Feature, isFeature, isStrictFeature } from './Domain/GeoJSON/Feature';
+export { FeatureCollection, isFeatureCollection, isStrictFeatureCollection } from './Domain/GeoJSON/FeatureCollection';
+export { GeoJSON, isGeoJSON, isStrictGeoJSON } from './Domain/GeoJSON/GeoJSON';

package/test/Domain/GeoJSON/Concept/Altitude.ts

@@ -0,0 +1,58 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/Altitude';
+import { exported } from '../../../helper/geometry';
+
+exported('Domain/GeoJSON/Concept/Altitude', Export, 'isAltitude', 'isStrictAltitude');
+
+const { isAltitude, isStrictAltitude } = Export;
+
+test('Domain/GeoJSON/Concept/Altitude - isAltitude', (t) => {
+	each`
+		input              | valid
+		-------------------|-------
+		${0}               | yes
+		${0.0000000001}    | yes
+		${1_234_567}       | yes
+		${-6_371_008.7714} | yes
+		${-6_378_137}      | yes
+		${20_180_000}      | yes
+		${20_180_000.1}    | yes
+		${-Infinity}       | no
+		${Infinity}        | no
+		${NaN}             | no
+		${'1234'}          | no
+		${false}           | no
+		${true}            | no
+	`(({ input, valid }) => {
+		t.equal(isAltitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/Altitude - isStrictAltitude', (t) => {
+	each`
+		input              | valid
+		-------------------|-------
+		${0}               | yes
+		${0.0000000001}    | yes
+		${1_234_567}       | yes
+		${-6_371_008.7714} | yes
+		${-6_371_008.7715} | no
+		${-6_378_137}      | no
+		${-6_378_137.1}    | no
+		${20_180_000}      | yes
+		${20_180_000.1}    | no
+		${-Infinity}       | no
+		${Infinity}        | no
+		${NaN}             | no
+		${'1234'}          | no
+		${false}           | no
+		${true}            | no
+	`(({ input, valid }) => {
+		t.equal(isStrictAltitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});

package/test/Domain/GeoJSON/Concept/BoundingBox.ts

@@ -0,0 +1,77 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/BoundingBox';
+import { exported } from '../../../helper/geometry';
+
+exported('Domain/GeoJSON/Concept/BoundingBox', Export, 'isBoundingBox', 'isStrictBoundingBox');
+
+const { isBoundingBox, isStrictBoundingBox } = Export;
+
+test('Domain/GeoJSON/Concept/BoundingBox - isBoundingBox', (t) => {
+	each`
+		input                                    | valid
+		-----------------------------------------|-------
+		${[-10.0, -10.0, 10.0, 10.0]}            | yes
+		${[100.0, 0.0, 105.0, 1.0]}              | yes
+		${[100.0, 0.0, -100.0, 105.0, 1.0, 0.0]} | yes
+		${[177.0, -20.0, -178.0, -16.0]}         | yes
+		${[-178.0, -20.0, 177.0, -16.0]}         | yes
+		${[-370.0, -190.0, 190.0, 370.0]}        | yes
+		${[]}                                    | no
+		${[0]}                                   | no
+		${[-180]}                                | no
+		${[0, 0]}                                | no
+		${[-180, -90]}                           | no
+		${[0, 0, 0]}                             | no
+		${[-180, -90, 180]}                      | no
+		${[0, 0, 0, 0]}                          | yes
+		${[-180, -90, 180, 90]}                  | yes
+		${[0, 0, 0, 0, 0]}                       | no
+		${[-180, -90, 0, 180, 90]}               | no
+		${[0, 0, 0, 0, 0, 0]}                    | yes
+		${[-180, -90, 0, 180, 90, 0]}            | yes
+		${[180, 90, 0, -180, -90, 0]}            | no
+		${[-180, 90, 0, 180, -90, 0]}            | no
+		${[180, -90, 0, -180, 90, 0]}            | yes
+		${[-181, -91, 0, 181, 91, 0]}            | yes
+	`(({ input, valid }) => {
+		t.equal(isBoundingBox(input), valid === 'yes', `[${input}] isBoudingBox ${valid}`)
+	});
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/BoundingBox - isStrictBoundingBox', (t) => {
+	each`
+		input                                    | valid
+		-----------------------------------------|-------
+		${[-10.0, -10.0, 10.0, 10.0]}            | yes
+		${[100.0, 0.0, 105.0, 1.0]}              | yes
+		${[100.0, 0.0, -100.0, 105.0, 1.0, 0.0]} | yes
+		${[177.0, -20.0, -178.0, -16.0]}         | yes
+		${[-178.0, -20.0, 177.0, -16.0]}         | yes
+		${[-370.0, -190.0, 190.0, 370.0]}        | no
+		${[]}                                    | no
+		${[0]}                                   | no
+		${[-180]}                                | no
+		${[0, 0]}                                | no
+		${[-180, -90]}                           | no
+		${[0, 0, 0]}                             | no
+		${[-180, -90, 180]}                      | no
+		${[0, 0, 0, 0]}                          | yes
+		${[-180, -90, 180, 90]}                  | yes
+		${[0, 0, 0, 0, 0]}                       | no
+		${[-180, -90, 0, 180, 90]}               | no
+		${[0, 0, 0, 0, 0, 0]}                    | yes
+		${[-180, -90, 0, 180, 90, 0]}            | yes
+		${[180, 90, 0, -180, -90, 0]}            | no
+		${[180, 90, 0, -180, -90, 0]}            | no
+		${[-180, 90, 0, 180, -90, 0]}            | no
+		${[180, -90, 0, -180, 90, 0]}            | yes
+		${[-181, -91, 0, 181, 91, 0]}            | no
+	`(({ input, valid }) => {
+		t.equal(isStrictBoundingBox(input), valid === 'yes', `[${input}] isStrictBoudingBox ${valid}`)
+	});
+
+	t.end();
+});

package/test/Domain/GeoJSON/Concept/ExteriorRing.ts

@@ -0,0 +1,65 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/ExteriorRing';
+import { exported } from '../../../helper/geometry';
+import { coordinates as Italy } from '../../../data/Italy';
+import { coordinates as SanMarino, polygon } from '../../../data/SanMarino';
+import { coordinates as HolySee } from '../../../data/HolySee';
+
+exported('Domain/GeoJSON/Concept/ExteriorRing', Export, 'isExteriorRing', 'isStrictExteriorRing');
+
+const { isExteriorRing, isStrictExteriorRing } = Export;
+
+test('Domain/GeoJSON/Concept/ExteriorRing - isExteriorRing', (t) => {
+	each`
+		input                                            | valid
+		-------------------------------------------------|----
+		${undefined}                                     | no
+		${null}                                          | no
+		${'[[1,0],[1,1],[0,1],[1,0]]'}                   | no
+		${[[1, 0], [1, 1], [0, 1], [0, 0.5], [1, 0]]}    | yes
+		${[[1, 0], [0, 0.5], [0, 1], [1, 1], [1, 0]]}    | yes
+		${[[1, 0], [1, 1], [0, 1], [1, 0]]}              | yes
+		${[[1, 0], [1, 1], [0, 1], [0, 0]]}              | no
+		${[[1, 0], [1, 1], [1, 0]]}                      | no
+		${[[1, 0], [1, 0]]}                              | no
+		${[[1, 0]]}                                      | no
+		${[[-181, -91], [0, -91], [0, 91], [-181, -91]]} | yes
+	`(({ input, valid }) => {
+		t.equal(isExteriorRing(input), valid === 'yes', `[${input}] isExteriorRing ${valid}`);
+	});
+
+	t.ok(Italy.every((polygon) => polygon.every(isExteriorRing)), 'coordinates for Italy polygon all match isExteriorRing');
+	t.notOk(SanMarino.every(isExteriorRing), 'coordinates for SanMarino does not match isExteriorRing');
+	t.notOk(HolySee.every(isExteriorRing), 'coordinates for HolySee does not match isExteriorRing');
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/ExteriorRing - isStrictExteriorRing', (t) => {
+	each`
+		input                                            | valid
+		-------------------------------------------------|----
+		${undefined}                                     | no
+		${null}                                          | no
+		${'[[1,0],[1,1],[0,1],[1,0]]'}                   | no
+		${[[1, 0], [1, 1], [0, 1], [0, 0.5], [1, 0]]}    | no
+		${[[1, 0], [0, 0.5], [0, 1], [1, 1], [1, 0]]}    | yes
+		${[[1, 0], [1, 1], [0, 1], [1, 0]]}              | no
+		${[[1, 0], [1, 1], [0, 1], [0, 0]]}              | no
+		${[[1, 0], [1, 1], [1, 0]]}                      | no
+		${[[1, 0], [1, 0]]}                              | no
+		${[[1, 0]]}                                      | no
+		${[[-181, -91], [0, -91], [0, 91], [-181, -91]]} | no
+	`(({ input, valid }) => {
+		t.equal(isStrictExteriorRing(input), valid === 'yes', `[${input}] isStrictExteriorRing ${valid}`);
+	});
+
+	t.notOk(Italy.every((polygon) => polygon.every(isStrictExteriorRing)), 'coordinates for Italy polygon do not match isStrictExteriorRing');
+	t.ok(Italy.every((polygon) => isStrictExteriorRing(polygon[0])), 'first polygon coordinates for Italy all match isStrictExteriorRing');
+	t.ok(Italy.filter((polygon) => polygon.length > 1).every((polygon) => !polygon.slice(1).some(isStrictExteriorRing)), 'second+ polygon coordinates for Italy none match isStrictExteriorRing')
+	t.notOk(SanMarino.every(isStrictExteriorRing), 'coordinates for SanMarino does not match isStrictExteriorRing');
+	t.notOk(HolySee.every(isStrictExteriorRing), 'coordinates for HolySee does not match isStrictExteriorRing');
+
+	t.end();
+});