@konfirm/geojson 1.0.0 → 1.0.1-beta.0

package/source/Domain/Utility/Calculate.ts

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

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

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

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

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

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

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

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

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

@@ -1,65 +0,0 @@
-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();
-});

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

@@ -1,56 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/GeoJSONObject';
-import { exported } from '../../../helper/geometry';
-
-exported('Domain/GeoJSON/Concept/GeoJSONObject', Export, 'isGeoJSONObject', 'isStrictGeoJSONObject');
-
-const { isGeoJSONObject, isStrictGeoJSONObject } = Export;
-
-test('Domain/GeoJSON/Concept/GeoJSONObject - isGeoJSONObject', (t) => {
-	each`
-		type         | bbox                          | valid
-		-------------|-------------------------------|-------
-		Type         |                               | yes
-		Type         | ${[0, 0, 0, 0]}               | yes
-		Type         | ${[0, 0, 0, 0, 0, 0]}         | yes
-		Type         | ${[-181, -91, 0, 181, 91, 0]} | yes
-		${undefined} |                               | no
-		${null}      |                               | no
-		${true}      |                               | no
-		${false}     |                               | no
-		${12345}     |                               | no
-	`(({ type, bbox, valid }: any) => {
-		const validate = isGeoJSONObject(type);
-		const input = Object.assign({ type }, bbox ? { bbox } : {});
-
-		t.equal(typeof validate, 'function', `creates isGeoJSONObject validator for type ${JSON.stringify(type)}`);
-		t.equal(validate(input), valid === 'yes', `type ${JSON.stringify(type)} validates ${JSON.stringify(input)} ${valid}`);
-	});
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/GeoJSONObject - isStrictGeoJSONObject', (t) => {
-	each`
-		type         | bbox                          | valid
-		-------------|-------------------------------|-------
-		Type         |                               | yes
-		Type         | ${[0, 0, 0, 0]}               | yes
-		Type         | ${[0, 0, 0, 0, 0, 0]}         | yes
-		Type         | ${[-181, -91, 0, 181, 91, 0]} | no
-		${undefined} |                               | no
-		${null}      |                               | no
-		${true}      |                               | no
-		${false}     |                               | no
-		${12345}     |                               | no
-	`(({ type, bbox, valid }: any) => {
-		const validate = isStrictGeoJSONObject(type);
-		const input = Object.assign({ type }, bbox ? { bbox } : {});
-
-		t.equal(typeof validate, 'function', `creates isStrictGeoJSONObject validator for type ${JSON.stringify(type)}`);
-		t.equal(validate(input), valid === 'yes', `type ${JSON.stringify(type)} validates ${JSON.stringify(input)} ${valid}`);
-	});
-
-	t.end();
-});

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

@@ -1,65 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../../source/Domain/GeoJSON/Concept/InteriorRing';
-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/InteriorRing', Export, 'isInteriorRing', 'isStrictInteriorRing');
-
-const { isInteriorRing, isStrictInteriorRing } = Export;
-
-test('Domain/GeoJSON/Concept/InteriorRing - isInteriorRing', (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(isInteriorRing(input), valid === 'yes', `[${input}] isInteriorRing ${valid}`);
-	});
-
-	t.ok(Italy.every((polygon) => polygon.every(isInteriorRing)), 'coordinates for Italy polygon all match isInteriorRing');
-	t.notOk(SanMarino.every(isInteriorRing), 'coordinates for SanMarino does not match isInteriorRing');
-	t.notOk(HolySee.every(isInteriorRing), 'coordinates for HolySee does not match isInteriorRing');
-
-	t.end();
-});
-
-test('Domain/GeoJSON/Concept/InteriorRing - isStrictInteriorRing', (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]]}    | no
-		${[[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]]} | no
-	`(({ input, valid }) => {
-		t.equal(isStrictInteriorRing(input), valid === 'yes', `[${input}] isStrictInteriorRing ${valid}`);
-	});
-
-	t.notOk(Italy.every((polygon) => polygon.every(isStrictInteriorRing)), 'coordinates for Italy polygon do not match isStrictInteriorRing');
-	t.ok(Italy.every((polygon) => !isStrictInteriorRing(polygon[0])), 'first polygon coordinates for Italy none match isStrictInteriorRing');
-	t.ok(Italy.filter((polygon) => polygon.length > 1).every((polygon) => polygon.slice(1).every(isStrictInteriorRing)), 'second+ polygon coordinates for Italy none match isStrictInteriorRing')
-	t.notOk(SanMarino.every(isStrictInteriorRing), 'coordinates for SanMarino does not match isStrictInteriorRing');
-	t.notOk(HolySee.every(isStrictInteriorRing), 'coordinates for HolySee does not match isStrictInteriorRing');
-
-	t.end();
-});