@konfirm/geojson 1.0.0

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

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

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

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

@@ -0,0 +1,56 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/Latitude';
+import { exported } from '../../../helper/geometry';
+
+exported('Domain/GeoJSON/Concept/Latitude', Export, 'isLatitude', 'isStrictLatitude');
+
+const { isLatitude, isStrictLatitude } = Export;
+
+test('Domain/GeoJSON/Concept/Latitude - isLatitude', (t) => {
+	each`
+		input           | valid
+		----------------|-------
+		${0}            | yes
+		${0.0000000001} | yes
+		${51.9851034}   | yes
+		${-90}          | yes
+		${-90.1}        | yes
+		${90}           | yes
+		${90.1}         | yes
+		${-Infinity}    | no
+		${Infinity}     | no
+		${NaN}          | no
+		${'1234'}       | no
+		${false}        | no
+		${true}         | no
+	`(({ input, valid }) => {
+		t.equal(isLatitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/Latitude - isStrictLatitude', (t) => {
+	each`
+		input           | valid
+		----------------|-------
+		${0}            | yes
+		${0.0000000001} | yes
+		${51.9851034}   | yes
+		${-90}          | yes
+		${-90.1}        | no
+		${90}           | yes
+		${90.1}         | no
+		${-Infinity}    | no
+		${Infinity}     | no
+		${NaN}          | no
+		${'1234'}       | no
+		${false}        | no
+		${true}         | no
+	`(({ input, valid }) => {
+		t.equal(isStrictLatitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});

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

@@ -0,0 +1,63 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/LinearRing';
+import { exported } from '../../../helper/geometry';
+import { coordinates as Italy } from '../../../data/Italy';
+import { coordinates as SanMarino } from '../../../data/SanMarino';
+import { coordinates as HolySee } from '../../../data/HolySee';
+
+exported('Domain/GeoJSON/Concept/LinearRing', Export, 'isLinearRing', 'isStrictLinearRing');
+
+const { isLinearRing, isStrictLinearRing } = Export;
+
+test('Domain/GeoJSON/Concept/LinearRing - isLinearRing', (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(isLinearRing(input), valid === 'yes', `[${input}] isLinearRing ${valid}`);
+	});
+
+	t.ok(Italy.every((polygon) => polygon.every(isLinearRing)), 'coordinates for Italy polygon all match isLinearRing');
+	t.notOk(SanMarino.every(isLinearRing), 'coordinates for SanMarino does not match isLinearRing');
+	t.notOk(HolySee.every(isLinearRing), 'coordinates for HolySee does not match isLinearRing');
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/LinearRing - isStrictLinearRing', (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]]} | no
+	`(({ input, valid }) => {
+		t.equal(isStrictLinearRing(input), valid === 'yes', `[${input}] isStrictLinearRing ${valid}`);
+	});
+
+	t.ok(Italy.every((polygon) => polygon.every(isStrictLinearRing)), 'coordinates for Italy polygon all match isStrictLinearRing');
+	t.notOk(SanMarino.every(isStrictLinearRing), 'coordinates for SanMarino does not match isStrictLinearRing');
+	t.notOk(HolySee.every(isStrictLinearRing), 'coordinates for HolySee does not match isStrictLinearRing');
+
+	t.end();
+});

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

@@ -0,0 +1,56 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/Longitude';
+import { exported } from '../../../helper/geometry';
+
+exported('Domain/GeoJSON/Concept/Longitude', Export, 'isLongitude', 'isStrictLongitude');
+
+const { isLongitude, isStrictLongitude } = Export;
+
+test('Domain/GeoJSON/Concept/Longitude - isLongitude', (t) => {
+	each`
+		input           | valid
+		----------------|-------
+		${0}            | yes
+		${0.0000000001} | yes
+		${5.8987296}    | yes
+		${-180}         | yes
+		${-180.1}       | yes
+		${180}          | yes
+		${180.1}        | yes
+		${-Infinity}    | no
+		${Infinity}     | no
+		${NaN}          | no
+		${'1234'}       | no
+		${false}        | no
+		${true}         | no
+	`(({ input, valid }) => {
+		t.equal(isLongitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/Longitude - isStrictLongitude', (t) => {
+	each`
+		input           | valid
+		----------------|-------
+		${0}            | yes
+		${0.0000000001} | yes
+		${5.8987296}    | yes
+		${-180}         | yes
+		${-180.1}       | no
+		${180}          | yes
+		${180.1}        | no
+		${-Infinity}    | no
+		${Infinity}     | no
+		${NaN}          | no
+		${'1234'}       | no
+		${false}        | no
+		${true}         | no
+	`(({ input, valid }) => {
+		t.equal(isStrictLongitude(input), valid === 'yes', `${input} ${valid}`);
+	});
+
+	t.end();
+});

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

@@ -0,0 +1,56 @@
+import test from 'tape';
+import * as Export from '../../../../source/Domain/GeoJSON/Concept/Position';
+import { coordinates } from '../../../data/HolySee';
+import { exported } from '../../../helper/geometry';
+
+exported('Domain/GeoJSON/Concept/Position', Export, 'isPosition', 'isStrictPosition', 'isEquivalentPosition');
+
+const { isPosition, isStrictPosition, isEquivalentPosition } = Export;
+const altitude = coordinates.map(([lon, lat, alt = 1.23]) => [lon, lat, alt]);
+
+test('Domain/GeoJSON/Concept/Position - isPosition', (t) => {
+	t.ok(coordinates.every(isPosition), 'all coordinates match isPosition');
+	t.ok(altitude.every(isPosition), 'all coordinates with altitude match isPosition');
+
+	t.notOk(isPosition([Infinity, 0, 0]), `[Infinity, 0, 0] is not a Position`);
+	t.notOk(isPosition([0, Infinity, 0]), `[0, Infinity, 0] is not a Position`);
+	t.notOk(isPosition([0, 0, Infinity]), `[0, 0, Infinity] is not a Position`);
+	t.ok(isPosition([0, 0, 0]), `[0, 0, 0] is Position`);
+	t.ok(isPosition([-181, 0, 0]), `[-181, 0, 0] is Position`);
+	t.ok(isPosition([0, -91, 0]), `[0, -91, 0] is Position`);
+	t.ok(isPosition([0, 0, -7000000]), `[0, 0, -7000000] is Position`);
+	t.ok(isPosition([-181, -91, 0]), `[-181, -91, 0] is Position`);
+	t.ok(isPosition([0, -91, -7000000]), `[0, -91, -7000000] is Position`);
+	t.ok(isPosition([-181, 0, -7000000]), `[-181, 0, -7000000] is Position`);
+	t.ok(isPosition([-181, -91, -7000000]), `[-181, -91, -7000000] is Position`);
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/Position - isStrictPosition', (t) => {
+	t.ok(coordinates.every(isStrictPosition), 'all coordinates match isStrictPosition');
+	t.ok(altitude.every(isStrictPosition), 'all coordinates with altitude match isStrictPosition');
+
+	t.notOk(isStrictPosition([Infinity, 0, 0]), `[Infinity, 0, 0] is not a strict Position`);
+	t.notOk(isStrictPosition([0, Infinity, 0]), `[0, Infinity, 0] is not a strict Position`);
+	t.notOk(isStrictPosition([0, 0, Infinity]), `[0, 0, Infinity] is not a strict Position`);
+	t.ok(isStrictPosition([0, 0, 0]), `[0, 0, 0] is strict Position`);
+	t.notOk(isStrictPosition([-181, 0, 0]), `[-181, 0, 0] is not a strict Position`);
+	t.notOk(isStrictPosition([0, -91, 0]), `[0, -91, 0] is not a strict Position`);
+	t.notOk(isStrictPosition([0, 0, -7000000]), `[0, 0, -7000000] is not a strict Position`);
+	t.notOk(isStrictPosition([-181, -91, 0]), `[-181, -91, 0] is not a strict Position`);
+	t.notOk(isStrictPosition([0, -91, -7000000]), `[0, -91, -7000000] is not a strict Position`);
+	t.notOk(isStrictPosition([-181, 0, -7000000]), `[-181, 0, -7000000] is not a strict Position`);
+	t.notOk(isStrictPosition([-181, -91, -7000000]), `[-181, -91, -7000000] is not a strict Position`);
+
+	t.end();
+});
+
+test('Domain/GeoJSON/Concept/Position - isEquivalentPosition', (t) => {
+	t.ok(isEquivalentPosition([1.23456789, 2.3456789], [1.23456789, 2.3456789]), `[1.23456789,2.3456789] and [1.23456789,2.3456789] are equivalent`);
+	t.ok(isEquivalentPosition([1.23456789, 2.3456789, 3.456789], [1.23456789, 2.3456789, 3.456789]), `[1.23456789,2.3456789,3.456789] and [1.23456789,2.3456789,3.456789] are equivalent`);
+	t.notOk(isEquivalentPosition([1.23456789, 2.3456789, 3.456789], [1.23456789, 2.3456789]), `[1.23456789,2.3456789,3.456789] and [1.23456789,2.3456789] are not equivalent`);
+	t.notOk(isEquivalentPosition([1.23456789, 2.3456789], [1.23456789, 2.3456789, , 3.456789]), `[1.23456789,2.3456789] and [1.23456789,2.3456789,,3.456789] are not equivalent`);
+
+	t.end();
+});

package/test/Domain/GeoJSON/Feature.ts

@@ -0,0 +1,9 @@
+import * as Export from '../../../source/Domain/GeoJSON/Feature';
+import { runner } from '../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Feature',
+	Export,
+	'isFeature',
+	'isStrictFeature',
+);

package/test/Domain/GeoJSON/FeatureCollection.ts

@@ -0,0 +1,9 @@
+import * as Export from '../../../source/Domain/GeoJSON/FeatureCollection';
+import { runner } from '../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/FeatureCollection',
+	Export,
+	'isFeatureCollection',
+	'isStrictFeatureCollection',
+);

package/test/Domain/GeoJSON/GeoJSON.ts

@@ -0,0 +1,21 @@
+import * as Export from '../../../source/Domain/GeoJSON/GeoJSON';
+import { runner } from '../../helper/geometry';
+
+const types = [
+	'Point',
+	'MultiPoint',
+	'LineString',
+	'MultiLineString',
+	'Polygon',
+	'MultiPolygon',
+	'GeometryCollection',
+	'Feature',
+	'FeatureCollection',
+]
+
+runner(
+	'Domain/GeoJSON/GeoJSON',
+	Export,
+	['isGeoJSON', types],
+	['isStrictGeoJSON', types],
+);

package/test/Domain/GeoJSON/Geometry/LineString.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/LineString';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/LineString',
+	Export,
+	['isLineStringCoordinates', ['MultiPoint']],
+	'isLineString',
+	['isStrictLineStringCoordinates', ['MultiPoint']],
+	'isStrictLineString',
+);

package/test/Domain/GeoJSON/Geometry/MultiLineString.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiLineString';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/MultiLineString',
+	Export,
+	['isMultiLineStringCoordinates', ['Polygon']],
+	'isMultiLineString',
+	['isStrictMultiLineStringCoordinates', ['Polygon']],
+	'isStrictMultiLineString',
+);

package/test/Domain/GeoJSON/Geometry/MultiPoint.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiPoint';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/MultiPoint',
+	Export,
+	['isMultiPointCoordinates', ['LineString']],
+	'isMultiPoint',
+	['isStrictMultiPointCoordinates', ['LineString']],
+	'isStrictMultiPoint',
+);

package/test/Domain/GeoJSON/Geometry/MultiPolygon.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/MultiPolygon';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/MultiPolygon',
+	Export,
+	'isMultiPolygonCoordinates',
+	'isMultiPolygon',
+	'isStrictMultiPolygonCoordinates',
+	'isStrictMultiPolygon',
+);

package/test/Domain/GeoJSON/Geometry/Point.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/Point';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/Point',
+	Export,
+	'isPointCoordinates',
+	'isPoint',
+	'isStrictPointCoordinates',
+	'isStrictPoint',
+);

package/test/Domain/GeoJSON/Geometry/Polygon.ts

@@ -0,0 +1,11 @@
+import * as Export from '../../../../source/Domain/GeoJSON/Geometry/Polygon';
+import { runner } from '../../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry/Polygon',
+	Export,
+	'isPolygonCoordinates',
+	'isPolygon',
+	'isStrictPolygonCoordinates',
+	'isStrictPolygon',
+);

package/test/Domain/GeoJSON/Geometry.ts

@@ -0,0 +1,9 @@
+import * as Export from '../../../source/Domain/GeoJSON/Geometry';
+import { runner } from '../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/Geometry',
+	Export,
+	['isGeometry', ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon']],
+	['isStrictGeometry', ['Point', 'MultiPoint', 'LineString', 'MultiLineString', 'Polygon', 'MultiPolygon']],
+);

package/test/Domain/GeoJSON/GeometryCollection.ts

@@ -0,0 +1,9 @@
+import * as Export from '../../../source/Domain/GeoJSON/GeometryCollection';
+import { runner } from '../../helper/geometry';
+
+runner(
+	'Domain/GeoJSON/GeometryCollection',
+	Export,
+	'isGeometryCollection',
+	'isStrictGeometryCollection',
+);

package/test/Domain/GeoJSON/GeometryObject.ts

@@ -0,0 +1,4 @@
+import * as Export from '../../../source/Domain/GeoJSON/GeometryObject';
+import { exported } from '../../helper/geometry';
+
+exported('Domain/GeoJSON/GeometryObject', Export, 'isGeometryObject');

package/test/Domain/Guards/Number.ts

@@ -0,0 +1,49 @@
+import test from 'tape';
+import { each } from 'template-literal-each';
+import * as Export from '../../../source/Domain/Guards/Number';
+import { exported } from '../../helper/geometry';
+
+exported('Domain/Guards/Number - exports', Export, 'isNumberValue', 'isNumberBetween');
+
+const { isNumberValue, isNumberBetween } = Export;
+
+test('Domain/Guards/Number - isNumberValue', (t) => {
+	each`
+		input                      | valid
+		---------------------------|-------
+		${123}                     | yes
+		${Number.MAX_SAFE_INTEGER} | yes
+		${Number.MIN_SAFE_INTEGER} | yes
+		${Number.MAX_VALUE}        | yes
+		${Number.MIN_VALUE}        | yes
+		${Math.PI}                 | yes
+		${-Math.PI}                | yes
+		${Infinity}                | no
+		${-Infinity}               | no
+		${NaN}                     | no
+		${'123'}                   | no
+	`(({ input, valid }) => {
+		t.equal(isNumberValue(input), valid === 'yes', `${input} isNumberValue ${valid}`);
+	});
+
+	t.end();
+});
+
+test('Domain/Guards/Number - isNumberBetween', (t) => {
+	each`
+		input        | min    | max          | valid
+		-------------|--------|--------------|-------
+		${1}         | ${0}   | ${2}         | yes
+		${0}         | ${0}   | ${2}         | yes
+		${-1}        | ${0}   | ${2}         | no
+		${Infinity}  | ${0}   | ${undefined} | no
+		${Math.PI}   | ${0}   | ${undefined} | yes
+		${0}         | ${-10} | ${10}        | yes
+	`(({ input, min, max, valid }: any) => {
+		const between = isNumberBetween(min, max);
+
+		t.equal(between(input), valid === 'yes', `${input} is ${valid === 'no' ? 'not ' : ''}between ${min} and ${max}`);
+	});
+
+	t.end();
+});

package/test/Domain/Guards/Tuple.ts

@@ -0,0 +1,27 @@
+import { isBoolean, isNumber, isString } from '@konfirm/guard';
+import test from 'tape';
+import * as Export from '../../../source/Domain/Guards/Tuple';
+import { exported } from '../../helper/geometry';
+
+exported('Domain/Guards/Tuple - exports', Export, 'isTuple');
+
+const { isTuple } = Export;
+
+test('Domain/Guards/Tuple - isTuple', (t) => {
+	const snn = isTuple(isString, isNumber, isNumber);
+	const bsn = isTuple(isBoolean, isString, isNumber);
+
+	t.notOk(snn(['abc']), `['abc'] does not match isTuple(isString, isNumber, isNumber)`);
+	t.notOk(snn(['abc', 123]), `['abc', 123] does not match isTuple(isString, isNumber, isNumber)`);
+	t.ok(snn(['abc', 123, 456]), `['abc', 123, 456] matches isTuple(isString, isNumber, isNumber)`);
+	t.notOk(snn(['abc', 123, true]), `['abc', 123, true] does not match isTuple(isString, isNumber, isNumber)`);
+	t.notOk(snn(['abc', false, 123]), `['abc', false, 123] does not match isTuple(isString, isNumber, isNumber)`);
+	t.notOk(snn(['abc', 123, 456, 789]), `['abc', 456, 789, 123] does not match isTuple(isString, isNumber, isNumber)`);
+
+	t.notOk(bsn(['abc', 123]), `['abc', 123] does not match isTuple(isBoolean, isString, isNumber)`);
+	t.notOk(bsn(['abc', false, 123]), `['abc', false, 123] does not match isTuple(isBoolean, isString, isNumber)`);
+	t.ok(bsn([true, 'abc', 123]), `[true, 'abc', 123] matches isTuple(isBoolean, isString, isNumber)`);
+	t.ok(bsn([false, 'abc', 123]), `[false, 'abc', 123] matches isTuple(isBoolean, isString, isNumber)`);
+
+	t.end();
+});