@konfirm/geojson 1.0.0 → 1.0.1-beta.0

package/test/Domain/Iterator/SimpleGeometry.ts

@@ -1,195 +0,0 @@
-import test from 'tape';
-import * as Export from '../../../source/Domain/Iterator/SimpleGeometry';
-import { Point } from '../../../source/Domain/GeoJSON/Geometry/Point';
-import { MultiPoint } from '../../../source/Domain/GeoJSON/Geometry/MultiPoint';
-import { LineString } from '../../../source/Domain/GeoJSON/Geometry/LineString';
-import { MultiLineString } from '../../../source/Domain/GeoJSON/Geometry/MultiLineString';
-import { Polygon } from '../../../source/Domain/GeoJSON/Geometry/Polygon';
-import { MultiPolygon } from '../../../source/Domain/GeoJSON/Geometry/MultiPolygon';
-import { GeometryCollection } from '../../../source/Domain/GeoJSON/GeometryCollection';
-import { Feature } from '../../../source/Domain/GeoJSON/Feature';
-import { FeatureCollection } from '../../../source/Domain/GeoJSON/FeatureCollection';
-import { explain, exported } from '../../helper/geometry';
-
-const point: Point = { type: 'Point', coordinates: [0, 0] };
-const multipoint: MultiPoint = { type: 'MultiPoint', coordinates: [[1, 1], [2, 2]] };
-const linestring: LineString = { type: 'LineString', coordinates: [[3, 3], [4, 4]] };
-const multilinestring: MultiLineString = { type: 'MultiLineString', coordinates: [[[5, 5], [6, 6]], [[7, 7], [8, 8]], [[9, 9], [10, 10]]] };
-const polygon: Polygon = { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] };
-const multipolygon: MultiPolygon = { type: 'MultiPolygon', coordinates: [[[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]], [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]]] };
-const geometrycollection: GeometryCollection = { type: 'GeometryCollection', geometries: [point, multipoint] };
-const feature: Feature = { type: 'Feature', properties: null, geometry: linestring };
-const featurecollection: FeatureCollection = {
-    type: 'FeatureCollection', features: [
-        { type: 'Feature', properties: null, geometry: multilinestring },
-        { type: 'Feature', properties: null, geometry: polygon },
-        { type: 'Feature', properties: null, geometry: multipolygon },
-    ]
-};
-
-exported('Domain/Utility/SimpleGeometryIterator', Export, 'SimpleGeometryIterator');
-
-const { SimpleGeometryIterator } = Export;
-
-test('Domain/Utility/SimpleGeometryIterator - implements Symbol.iterator', (t) => {
-    const iterator = new SimpleGeometryIterator(point);
-
-    t.ok(Symbol.iterator in iterator, 'SimpleGeometryIterator implements Symbol.iterator');
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - Point with MultiPoint', (t) => {
-    const iterator = new SimpleGeometryIterator(point, multipoint);
-    const expanded = [...iterator];
-    const expected = [
-        point,
-        { type: 'Point', coordinates: [1, 1] },
-        { type: 'Point', coordinates: [2, 2] },
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - MultiPoint with LineString', (t) => {
-    const iterator = new SimpleGeometryIterator(multipoint, linestring);
-    const expanded = [...iterator];
-    const expected = [
-        { type: 'Point', coordinates: [1, 1] },
-        { type: 'Point', coordinates: [2, 2] },
-        linestring,
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - MultiPoint with MultiLineString', (t) => {
-    const iterator = new SimpleGeometryIterator(multipoint, multilinestring);
-    const expanded = [...iterator];
-    const expected = [
-        { type: 'Point', coordinates: [1, 1] },
-        { type: 'Point', coordinates: [2, 2] },
-        { type: 'LineString', coordinates: [[5, 5], [6, 6]] },
-        { type: 'LineString', coordinates: [[7, 7], [8, 8]] },
-        { type: 'LineString', coordinates: [[9, 9], [10, 10]] },
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - MultiLineString with Polygon', (t) => {
-    const iterator = new SimpleGeometryIterator(multilinestring, polygon);
-    const expanded = [...iterator];
-    const expected = [
-        { type: 'LineString', coordinates: [[5, 5], [6, 6]] },
-        { type: 'LineString', coordinates: [[7, 7], [8, 8]] },
-        { type: 'LineString', coordinates: [[9, 9], [10, 10]] },
-        polygon,
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - Polygon with MultiPolygon', (t) => {
-    const iterator = new SimpleGeometryIterator(polygon, multipolygon);
-    const expanded = [...iterator];
-    const expected = [
-        polygon,
-        { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] },
-        { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] },
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - Polygon with Feature', (t) => {
-    const iterator = new SimpleGeometryIterator(polygon, feature);
-    const expanded = [...iterator];
-    const expected = [
-        polygon,
-        linestring,
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});
-
-test('Domain/Utility/SimpleGeometryIterator - GeometryCollection with FeatureCollection', (t) => {
-    const iterator = new SimpleGeometryIterator(geometrycollection, featurecollection);
-    const expanded = [...iterator];
-    const expected = [
-        point,
-        { type: 'Point', coordinates: [1, 1] },
-        { type: 'Point', coordinates: [2, 2] },
-        { type: 'LineString', coordinates: [[5, 5], [6, 6]] },
-        { type: 'LineString', coordinates: [[7, 7], [8, 8]] },
-        { type: 'LineString', coordinates: [[9, 9], [10, 10]] },
-        polygon,
-        { type: 'Polygon', coordinates: [[[4, 4], [4, 5], [5, 5], [5, 4], [4, 4]]] },
-        { type: 'Polygon', coordinates: [[[0, 0], [0, 3], [3, 3], [3, 0], [0, 0]], [[1, 1], [2, 1], [2, 2], [1, 2], [1, 1]]] },
-    ];
-
-    t.equal(expanded.length, expected.length, `has ${expected.length} SimpleGeometry values`);
-
-    let index = 0;
-    for (const combo of iterator) {
-        const expect = expected[index++];
-
-        t.deepEqual(combo, expect, `${explain(combo)} is ${explain(expect)}}`);
-    }
-
-    t.end();
-});

package/test/Domain/Utility/Calculate.ts

@@ -1,178 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../source/Domain/Utility/Calculate';
-import { explain, exported } from '../../helper/geometry';
-
-exported('Domain/Utility/Calculate', Export, 'getClosestPointOnLineByPoint', 'getDistanceOfPointToPoint', 'getDistanceOfPointToLine', 'getDistanceOfLineToLine', 'isLinesCrossing', 'isPointOnLine', 'isPointInRing');
-
-test('Domain/Utility/Calculate - getDistanceOfPointToPoint', (t) => {
-    const { getDistanceOfPointToPoint } = Export;
-
-    each`
-        a                                         | b                                         | cartesian              | haversine                    | vincenty
-        ------------------------------------------|-------------------------------------------|------------------------|------------------------------|----------
-        ${[0, 0]}                                 | ${[1, 0]}                                 |   111195.07973436874   |   111195.07973436874         |   111319.49079322325
-        ${[0, 0]}                                 | ${[0, 1]}                                 |   111195.07973436874   |   111195.07973436874         |   110574.38855795695
-        ${[0, 0]}                                 | ${[1, 1]}                                 |   157253.589829502     |   157249.5977681334          |   156899.56829129544
-        ${[0, 0]}                                 | ${[2, 1]}                                 |   248639.75704955778   |   248629.6571521291          |   248575.56516788687
-        ${[0, 0]}                                 | ${[1, 2]}                                 |   248639.75704955778   |   248629.6571521291          |   247576.47264770948
-        ${[0, 0]}                                 | ${[2, 2]}                                 |   314507.179659004     |   314475.23806026357         |   313775.70942909684
-        ${[9, 9]}                                 | ${[1, 9]}                                 |   889560.63787495      |   878591.1714926899          |   879646.2426697082
-        ${[5.911760330200195, 51.97496770044958]} | ${[5.900301933288574, 51.97938231105512]} |     1365.4087816000642 |      925.6976780365701       |      927.9989469343577
-        ${[4.8422, 45.7597]}                      | ${[2.3508, 48.8567]}                      |   441970.48063825216   |   392217.2577987035          |   392431.52894877724
-        ${[-180, -90]}                            | ${[180, 90]}                              | 44755156.2689204       | 20015114.352186374           | 20003931.4586233
-        ${[-180, 90]}                             | ${[180, -90]}                             | 44755156.2689204       | 20015114.352186374           | 20003931.4586233
-        ${[-180, 0]}                              | ${[180, 0]}                               | 40030228.70437275      |        1.5604470998469443e-9 | 20003931.4586233
-    `(({ a, b, ...calc }: any) => {
-        Object.keys(calc).forEach((key) => {
-            const value = Number(calc[key]);
-            t.equal(getDistanceOfPointToPoint(a, b, key as any), value, `${key} distance from ${explain(a)} to ${explain(b)} is ${value}`);
-        });
-    });
-
-    t.equal(getDistanceOfPointToPoint([0, 0], [0, 0], () => Math.PI), Math.PI, 'Allows for custom function');
-    t.throws(() => getDistanceOfPointToPoint([0, 0], [1, 1], <any>'unknown'), /Not a PointToPoint calculation function unknown/);
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - getDistanceOfPointToLine', (t) => {
-    const { getDistanceOfPointToLine } = Export;
-    const line = [[5.911760330200195, 51.97496770044958], [5.900301933288574, 51.97938231105512]];
-
-    each`
-        point                                      | line                | cartesian             | haversine             | vincenty         
-        -------------------------------------------|---------------------|-----------------------|-----------------------|----------
-        ${[1, 1]}                                  | ${[[0, 0], [3, 3]]} |      0                |      0                |      0
-        ${[2, 1]}                                  | ${[[0, 0], [3, 3]]} |  78626.794914751      |  78617.31500879859    |  78442.46603900737
-        ${[1, 2]}                                  | ${[[0, 0], [3, 3]]} |  78626.794914751      |  78608.33580070207    |  78433.68568647826
-        ${[5, 2]}                                  | ${[[0, 0], [9, 0]]} | 222390.1594687375     | 222390.1594687375     | 221149.45337244959
-        ${[5, 2]}                                  | ${[[0, 0], [0, 9]]} | 555975.3986718437     | 555636.4985775814     | 556260.4424545396
-        ${[1, 1]}                                  | ${[[0, 0], [9, 0]]} | 111195.07973436874    | 111195.07973436874    | 110574.38855795695
-        ${[3, 1]}                                  | ${[[0, 0], [9, 0]]} | 111195.07973436874    | 111195.07973436874    | 110574.38855795695
-        ${[5, 1]}                                  | ${[[0, 0], [9, 0]]} | 111195.07973436874    | 111195.07973436874    | 110574.38855795695
-        ${[7, 1]}                                  | ${[[0, 0], [9, 0]]} | 111195.07973436874    | 111195.07973436874    | 110574.38855795695
-        ${[5.909668207168579, 51.979065108032444]} | ${line}             |    341.51430750144857 |    327.53158580286527 |    327.7879564857677
-    `(({ point, line, ...calc }: any) => {
-        Object.keys(calc).forEach((key) => {
-            const value = Number(calc[key]);
-            t.equal(getDistanceOfPointToLine(point, line, key as any), value, `${key} distance from ${explain(point)} to ${explain(line)} is ${value}`);
-        });
-    });
-
-    t.equal(getDistanceOfPointToLine([0, 0], [[0, 0], [1, 1]], () => Math.PI), Math.PI, 'Allows for custom function');
-    t.throws(() => getDistanceOfPointToLine([0, 0], [[0, 0], [1, 1]], <any>'unknown'), /Not a PointToPoint calculation function unknown/);
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - getDistanceOfLineToLine', (t) => {
-    const { getDistanceOfLineToLine } = Export;
-
-    each`
-        a                    | b                    | cartesian          | haversine          | vincenty
-        ---------------------|----------------------|--------------------|--------------------|----------
-        ${[[1, 1], [2, 2]]}  | ${[[0, 0], [3, 3]]}  |      0             |      0             |      0
-        ${[[1, 1], [20, 2]]} | ${[[0, 0], [30, 2]]} |  73965.86679042356 |  73965.72628462575 |  73555.60559277069
-        ${[[2, 2], [4, 2]]}  | ${[[1, 1], [5, 1]]}  | 111195.07973436874 | 111195.07973436874 | 110575.06481449273
-        ${[[2, 2], [4, 2]]}  | ${[[1, 1], [1, 5]]}  | 111195.07973436874 | 111127.34097821356 | 111252.1298001606
-        ${[[2, 2], [4, 2]]}  | ${[[1, 1], [5, 5]]}  |      0             |      0             |      0
-        ${[[0, 0], [2, 0]]}  | ${[[1, 1], [1, 3]]}  | 111195.07973436874 | 111195.07973436874 | 110574.38855795695
-        ${[[0, 0], [0, 5]]}  | ${[[3, 3], [9, 3]]}  | 333585.23920310626 | 333127.967966738   | 333503.7471426487
-    `(({ a, b, ...calc }: any) => {
-        Object.keys(calc).forEach((key) => {
-            const value = Number(calc[key]);
-            t.equal(getDistanceOfLineToLine(a, b, key as any), value, `${key} distance from ${explain(a)} to ${explain(b)} is ${value}`);
-        });
-    });
-
-    t.equal(getDistanceOfLineToLine([[0, 0], [1, 1]], [[0, 0], [1, 1]], () => Math.PI), Math.PI, 'Allows for custom function');
-    t.throws(() => getDistanceOfLineToLine([[0, 0], [0, 1]], [[1, 0], [1, 1]], <any>'unknown'), /Not a PointToPoint calculation function unknown/);
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - getClosestPointOnLineByPoint', (t) => {
-    const { getClosestPointOnLineByPoint } = Export;
-
-    each`
-        point                                      | line                                                                                | closest
-        -------------------------------------------|-------------------------------------------------------------------------------------|---------
-        ${[1, 1]}                                  | ${[[0, 0], [3, 3]]}                                                                 | ${[1, 1]}
-        ${[2, 1]}                                  | ${[[0, 0], [3, 3]]}                                                                 | ${[1.5, 1.5]}
-        ${[1, 2]}                                  | ${[[0, 0], [3, 3]]}                                                                 | ${[1.5, 1.5]}
-        ${[5, 2]}                                  | ${[[0, 0], [9, 0]]}                                                                 | ${[5, 0]}
-        ${[5, 2]}                                  | ${[[0, 0], [0, 9]]}                                                                 | ${[0, 2]}
-        ${[5.909668207168579, 51.979065108032444]} | ${[[5.911760330200195, 51.97496770044958], [5.900301933288574, 51.97938231105512]]} | ${[5.9085640303798, 51.97619914837327]}
-    `(({ point, line, closest }: any) => {
-        t.deepEqual(getClosestPointOnLineByPoint(point, line), closest, `${explain(point)} to ${explain(line)} is ${closest}`);
-    });
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - isLinesCrossing', (t) => {
-    const { isLinesCrossing } = Export;
-
-    each`
-        a                      | b                      | crosses
-        -----------------------|------------------------|----------
-        ${[[0, 0], [2, 2]]}    | ${[[0, 1], [2, 1]]}    | yes
-        ${[[0, 1], [9, 2]]}    | ${[[0, 2], [9, 1]]}    | yes
-        ${[[0, 1], [9, 2]]}    | ${[[0, 2], [9, 3]]}    | no
-        ${[[0, 1], [1000, 2]]} | ${[[0, 2], [1000, 3]]} | no
-    `(({ a, b, crosses }: any) => {
-        const crossed = crosses === 'yes';
-        const message = crossed ? 'crosses' : 'does not cross';
-        t.equal(isLinesCrossing(a, b), crossed, `${explain(a)} ${message} ${explain(b)}`);
-    });
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - isPointOnLine', (t) => {
-    const { isPointOnLine } = Export;
-
-    each`
-        point                                      | line                                                                                | match
-        -------------------------------------------|-------------------------------------------------------------------------------------|----------
-        ${[1, 1]}                                  | ${[[0, 0], [3, 3]]}                                                                 | yes
-        ${[2, 1]}                                  | ${[[0, 0], [3, 3]]}                                                                 | no
-        ${[1, 2]}                                  | ${[[0, 0], [3, 3]]}                                                                 | no
-        ${[5, 2]}                                  | ${[[0, 0], [9, 0]]}                                                                 | no
-        ${[5, 2]}                                  | ${[[0, 0], [0, 9]]}                                                                 | no
-        ${[5.909668207168579, 51.979065108032444]} | ${[[5.911760330200195, 51.97496770044958], [5.900301933288574, 51.97938231105512]]} | no
-        ${[5.906031131744385, 51.97717500575235]}  | ${[[5.911760330200195, 51.97496770044958], [5.900301933288574, 51.97938231105512]]} | yes
-    `(({ point, line, match }: any) => {
-        const output = match === 'yes';
-        const message = output ? 'is on line' : 'is not on line';
-
-        t.equal(isPointOnLine(point, line), output, `${explain(point)} ${message} ${explain(line)}`);
-    });
-
-    t.end();
-});
-
-test('Domain/Utility/Calculate - isPointInRing', (t) => {
-    const { isPointInRing } = Export;
-
-    each`
-        point        | ring                                        | match
-        -------------|---------------------------------------------|----------
-        ${[0, 0]}    | ${[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]} | yes
-        ${[2, 2]}    | ${[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]} | yes
-        ${[1, 1]}    | ${[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]} | yes
-        ${[3, 1]}    | ${[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]} | no
-        ${[1, 3]}    | ${[[0, 0], [0, 2], [2, 2], [2, 0], [0, 0]]} | no
-        ${[0, 0]}    | ${[[1, 0], [0, 1], [1, 2], [2, 1], [1, 0]]} | no
-        ${[2, 2]}    | ${[[1, 0], [0, 1], [1, 2], [2, 1], [1, 0]]} | no
-        ${[1, 1]}    | ${[[1, 0], [0, 1], [1, 2], [2, 1], [1, 0]]} | yes
-    `(({ point, ring, match }: any) => {
-        const output = match === 'yes';
-        const message = output ? 'is inside' : 'is not inside';
-
-        t.equal(isPointInRing(point, ring), output, `${explain(point)} ${message} ${explain(ring)}`);
-    });
-
-    t.end();
-});

package/test/Domain/Utility/Distance.ts

@@ -1,19 +0,0 @@
-import test from 'tape';
-import * as Export from '../../../source/Domain/Utility/Distance';
-import { explain, exported } from '../../helper/geometry';
-import { shapes } from '../../data/Distance';
-
-exported('Domain/Utility/Distance', Export, 'distance');
-
-const { distance } = Export;
-
-test(`Domain/Utility/Distance - distance`, (t) => {
-    shapes
-        .forEach(({ a, b, cartesian, haversine, vincenty }) => {
-            t.equal(distance(a, b), cartesian, `default calculation: ${explain(a)} to ${explain(b)} is ${cartesian}`);
-            t.equal(distance(a, b, 'cartesian'), cartesian, `'cartesian' calculation: ${explain(a)} to ${explain(b)} is ${cartesian}`);
-            t.equal(distance(a, b, 'haversine'), haversine, `'haversine' calculation: ${explain(a)} to ${explain(b)} is ${haversine}`);
-            t.equal(distance(a, b, 'vincenty'), vincenty, `'vincenty' calculation: ${explain(a)} to ${explain(b)} is ${vincenty}`);
-        });
-    t.end();
-});

package/test/Domain/Utility/Intersect.ts

@@ -1,54 +0,0 @@
-import test from 'tape';
-import * as Export from '../../../source/Domain/Utility/Intersect';
-import { explain, exported } from '../../helper/geometry';
-import { shapes } from '../../data/Intersect';
-
-exported('Domain/Utility/Intersect', Export, 'intersect');
-
-const { intersect } = Export;
-
-const types = ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon', 'GeometryCollection', 'Feature', 'FeatureCollection'];
-const combo = types.reduce((carry, a) => carry.concat(types.map((b) => [a, b])), [])
-
-combo.forEach(([ta, tb]) => {
-	const tests = shapes
-		.reduce((carry, { a, b, intersect }) => {
-			if (a.type === ta && b.type === tb) {
-				return carry.concat({ a, b, intersect });
-			}
-			if (a.type === tb && b.type === ta) {
-				return carry.concat({ a: b, b: a, intersect });
-			}
-
-			return carry;
-		}, []);
-	const hits = tests.filter(({ intersect }) => intersect);
-	const miss = tests.filter(({ intersect }) => !intersect);
-
-	test(`Domain/Utility/Intersect - intersect ${ta} with ${tb}`, (t) => {
-		hits.forEach(({ a, b }) => {
-			t.ok(intersect(a, b), `${explain(a)} intersects with ${explain(b)}`)
-		});
-		miss.forEach(({ a, b }) => {
-			t.notOk(intersect(a, b), `${explain(a)} does not intersect with ${explain(b)}`)
-		});
-
-		t.end();
-	});
-});
-
-test('Domain/Utility/Intersect - intersect Point with empty LineString', (t) => {
-	t.notOk(intersect({ type: 'Point', coordinates: [1, 1] }, { type: 'LineString', coordinates: [[0, 0], [0, 0]] }));
-
-	t.end();
-});
-
-test(`Domain/Utility/Intersect - intersect invalid GeoJSON types`, (t) => {
-	shapes
-		.filter(({ a, b }: any) => a.type === 'Impossible' || b.type === 'Impossible')
-		.forEach(({ a, b }: any) => {
-			t.notOk(intersect(a, b), `${explain(a)} does not intersect with ${explain(b)}`)
-		});
-
-	t.end();
-});

package/test/Domain/Utility/Numeric.ts

@@ -1,30 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../source/Domain/Utility/Numeric';
-import { exported } from '../../helper/geometry';
-
-exported('Domain/Utility/Numeric', Export, 'bounds');
-
-const { bounds } = Export;
-
-test('Domain/Utility/Numeric - bounds', (t) => {
-	each`
-		value                  | min     | max     | expect
-		-----------------------|---------|---------|--------
-		${1}                   | ${-1}   | ${1}    | ${1}
-		${100}                 | ${-1}   | ${1}    | ${0}
-		${1}                   | ${-1.5} | ${1.5}  | ${1}
-		${1}                   | ${1.5}  | ${-1.5} | ${1}
-		${5.911738872528076}   | ${-180} | ${180}  | ${5.911738872528076}
-		${-354.0882611274719}  | ${-180} | ${180}  | ${5.911738872528076}
-		${365.911738872528076} | ${-180} | ${180}  | ${5.911738872528076}
-		${51.97496770044958}   | ${-90}  | ${90}   | ${51.97496770044958}
-		${-128.02503229955042} | ${-90}  | ${90}   | ${51.97496770044958}
-		${231.97496770044958}  | ${-90}  | ${90}   | ${51.97496770044958}
-	`(({ value, min, max, expect }: any) => {
-		const rotate = bounds(min, max);
-		t.equal(rotate(value), expect, `${value} within bounds ${min} and ${max} is ${expect}`);
-	});
-
-	t.end();
-});

package/test/Domain/Utility/Winding.ts

@@ -1,52 +0,0 @@
-import test from 'tape';
-import { each } from 'template-literal-each';
-import * as Export from '../../../source/Domain/Utility/Winding';
-import { exported } from '../../helper/geometry';
-
-exported('Domain/Utility/Winding', Export, 'isClockwiseWinding', 'isCounterClockwiseWinding');
-
-const { isClockwiseWinding, isCounterClockwiseWinding } = Export;
-
-test('Domain/Utility/Winding - isClockwiseWinding', (t) => {
-	each`
-		position                                    | valid
-		--------------------------------------------|-------
-		${[[0, 0], [1, 0]]}                         | yes
-		${[[0, 0], [1, 0], [1, 1]]}                 | yes
-		${[[0, 0], [1, 0], [1, 1], [0, 1]]}         | yes
-		${[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]} | yes
-		${[[0, 0], [1, 0], [0, 1], [1, 1]]}         | yes
-		${[[0, 0]]}                                 | yes
-		${[[0, 0], [0, 1]]}                         | yes
-		${[[0, 0], [0, 1], [1, 1]]}                 | no
-		${[[0, 0], [0, 1], [1, 1], [1, 0]]}         | no
-		${[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]} | no
-		${[[1, 1], [0, 1], [1, 0], [0, 0]]}         | yes
-	`(({ position, valid }) => {
-		t.equal(isClockwiseWinding(position), valid === 'yes', `isClockwiseWinding ${JSON.stringify(position)} ${valid}`);
-	});
-
-	t.end();
-});
-
-test('Domain/Utility/Winding - isCounterClockwiseWinding', (t) => {
-	each`
-		position                                    | valid
-		--------------------------------------------|-------
-		${[[0, 0], [1, 0]]}                         | yes
-		${[[0, 0], [1, 0], [1, 1]]}                 | no
-		${[[0, 0], [1, 0], [1, 1], [0, 1]]}         | no
-		${[[0, 0], [1, 0], [1, 1], [0, 1], [0, 0]]} | no
-		${[[0, 0], [1, 0], [0, 1], [1, 1]]}         | yes
-		${[[0, 0]]}                                 | yes
-		${[[0, 0], [0, 1]]}                         | yes
-		${[[0, 0], [0, 1], [1, 1]]}                 | yes
-		${[[0, 0], [0, 1], [1, 1], [1, 0]]}         | yes
-		${[[0, 0], [0, 1], [1, 1], [1, 0], [0, 0]]} | yes
-		${[[1, 1], [0, 1], [1, 0], [0, 0]]}         | yes
-	`(({ position, valid }) => {
-		t.equal(isCounterClockwiseWinding(position), valid === 'yes', `isCounterClockwiseWinding ${JSON.stringify(position)} ${valid}`);
-	});
-
-	t.end();
-});

package/test/README.ts

@@ -1,123 +0,0 @@
-import test from 'tape';
-import { distance, Feature, FeatureCollection, GeometryCollection, intersect, LineString, MultiLineString, MultiPoint, Point, SimpleGeometryIterator } from '../source/main';
-
-test('README - intersect', (t) => {
-    const point: Point = {
-        type: 'Point',
-        coordinates: [1, 1],
-    };
-    const feature: Feature = {
-        type: 'Feature',
-        properties: {
-            name: 'triangle'
-        },
-        geometry: {
-            type: 'Polygon',
-            coordinates: [[[0, 0], [0, 2], [2, 1], [0, 0]]],
-        },
-    }
-
-    t.true(intersect(point, feature), 'point intersects feature');
-    t.true(intersect(feature, point), 'feature intersects point');
-
-    t.end();
-});
-
-test('README - distance', (t) => {
-    const a: Feature = {
-        type: 'Feature',
-        properties: {
-            name: 'Amsterdam Airport Schiphol',
-        },
-        geometry: {
-            type: 'Point',
-            coordinates: [4.763889, 52.308333],
-        },
-    };
-    const b: Feature = {
-        type: 'Feature',
-        properties: {
-            name: 'New York John F. Kennedy International Airport'
-        },
-        geometry: {
-            type: 'Point',
-            coordinates: [-73.778889, 40.639722],
-        },
-    };
-
-    t.equal(distance(a, b), 8829424.604594177, 'distance from a to b using default formula is 8829424.604594177');
-    t.equal(distance(a, b, 'cartesian'), 8829424.604594177, 'distance from a to b using cartesian formula is 8829424.604594177');
-    t.equal(distance(a, b, 'haversine'), 5847546.425707642, 'distance from a to b using haversine formula is 5847546.425707642');
-    t.equal(distance(a, b, 'vincenty'), 5863355.371234315, 'distance from a to b using vincenty formula is 5863355.371234315');
-
-    t.end();
-});
-
-test('README - SimpleGeometryIterator', (t) => {
-    const point: Point = {
-        type: 'Point',
-        coordinates: [5.903949737548828, 51.991936460056515],
-    };
-    const multipoint: MultiPoint = {
-        type: 'MultiPoint',
-        coordinates: [
-            [5.896482467651367, 52.00039200820837],
-            [5.888843536376953, 51.99912377779024],
-        ],
-    };
-    const linestring: LineString = {
-        type: 'LineString',
-        coordinates: [
-            [5.9077370166778564, 51.9944435645134],
-            [5.90764045715332, 51.994209045542206],
-            [5.907415151596069, 51.99408683094357],
-        ],
-    };
-    const multilinestring: MultiLineString = {
-        type: 'MultiLineString',
-        coordinates: [
-            [
-                [5.905205011367797, 51.99430813821511],
-                [5.905086994171143, 51.994261894995034],
-                [5.905033349990845, 51.99414958983319],
-                [5.9051138162612915, 51.994116558849626]
-            ],
-            [
-                [5.904818773269653, 51.993825885143515],
-                [5.905521512031555, 51.993551725259614],
-                [5.905789732933044, 51.99358805979856],
-            ],
-        ],
-    };
-    const geometrycollection: GeometryCollection = {
-        type: 'GeometryCollection',
-        geometries: [point],
-    };
-    const featurecollection: FeatureCollection = {
-        type: 'FeatureCollection',
-        features: [
-            {
-                type: 'Feature',
-                properties: {},
-                geometry: linestring,
-            },
-            {
-                type: 'Feature',
-                properties: {},
-                geometry: multilinestring,
-            },
-        ]
-    };
-
-    const expectation = []
-        .concat(multipoint.coordinates.map((coordinates) => ({ type: 'Point', coordinates })))
-        .concat(point)
-        .concat(linestring)
-        .concat(multilinestring.coordinates.map((coordinates) => ({ type: 'LineString', coordinates })));
-    const simplified = [...new SimpleGeometryIterator(multipoint, geometrycollection, featurecollection)];
-
-    console.dir(simplified);
-    t.deepEqual(simplified, expectation, 'provides all geometries in order');
-
-    t.end();
-});