@jscad/modeling 2.9.0 → 2.9.3

package/src/operations/transforms/center.test.js

@@ -13,10 +13,12 @@ test('center: centering of a path2 produces expected changes to points', (t) =>
   let centered = center({ axes: [true, false, false] }, geometry)
   let pts = path2.toPoints(centered)
   const exp = [[3, 0], [-2, 3], [-3, 0]]
+  t.notThrows(() => path2.validate(centered))
   t.true(comparePoints(pts, exp))
 
   centered = centerX(geometry)
   pts = path2.toPoints(centered)
+  t.notThrows(() => path2.validate(centered))
   t.true(comparePoints(pts, exp))
 })
 
@@ -27,10 +29,12 @@ test('center: centering of a geom2 produces expected changes to points', (t) =>
   let centered = center({ axes: [false, true, false] }, geometry)
   let pts = geom2.toPoints(centered)
   const exp = [[0, -5], [10, -5], [0, 5]]
+  t.notThrows(() => geom2.validate(centered))
   t.true(comparePoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom2.toPoints(centered)
+  t.notThrows(() => geom2.validate(centered))
   t.true(comparePoints(pts, exp))
 })
 
@@ -56,10 +60,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-5, -7, -12], [-5, 13, -12], [5, 13, -12], [5, -7, -12]],
     [[-5, -7, 18], [5, -7, 18], [5, 13, 18], [-5, 13, 18]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerX(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Y
@@ -73,10 +79,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -10, -12], [-2, 10, -12], [8, 10, -12], [8, -10, -12]],
     [[-2, -10, 18], [8, -10, 18], [8, 10, 18], [-2, 10, 18]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerY(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // center about Z
@@ -90,10 +98,12 @@ test('center: centering of a geom3 produces expected changes to polygons', (t) =
     [[-2, -7, -15], [-2, 13, -15], [8, 13, -15], [8, -7, -15]],
     [[-2, -7, 15], [8, -7, 15], [8, 13, 15], [-2, 13, 15]]
   ]
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   centered = centerZ(geometry)
   pts = geom3.toPoints(centered)
+  t.notThrows(() => geom3.validate(centered))
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -108,9 +118,11 @@ test('center: centering of multiple objects produces expected changes', (t) => {
 
   const pts1 = path2.toPoints(centered[1])
   const exp1 = [[2.5, 20], [12.5, 20], [2.5, 10], [17.5, 10]]
+  t.notThrows(() => path2.validate(centered[1]))
   t.true(comparePoints(pts1, exp1))
 
   const pts2 = geom2.toPoints(centered[2])
   const exp2 = [[2.5, 10], [7.5, 20], [17.5, 10]]
+  t.notThrows(() => geom2.validate(centered[2]))
   t.true(comparePoints(pts2, exp2))
 })

package/src/operations/transforms/mirror.test.js

@@ -13,20 +13,24 @@ test('mirror: mirroring of path2 about X/Y produces expected changes to points',
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = path2.toPoints(mirrored)
   let exp = [[5, 5], [-5, 5], [5, -5], [-10, -5]]
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = path2.toPoints(mirrored)
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = path2.toPoints(mirrored)
   exp = [[-5, -5], [5, -5], [-5, 5], [10, 5]]
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = path2.toPoints(mirrored)
+  t.notThrows(() => path2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 })
 
@@ -37,20 +41,24 @@ test('mirror: mirroring of geom2 about X/Y produces expected changes to points',
   let mirrored = mirror({ normal: [1, 0, 0] }, geometry)
   let obs = geom2.toPoints(mirrored)
   let exp = [[5, -5], [0, 5], [-10, -5]]
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorX(geometry)
   obs = geom2.toPoints(mirrored)
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   // mirror about Y
   mirrored = mirror({ normal: [0, 1, 0] }, geometry)
   obs = geom2.toPoints(mirrored)
   exp = [[-5, 5], [0, -5], [10, 5]]
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom2.toPoints(mirrored)
+  t.notThrows(() => geom2.validate(mirrored))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,11 +84,13 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[-8, -7, -12], [-8, 13, -12], [2, 13, -12], [2, -7, -12]],
     [[2, 13, 18], [-8, 13, 18], [-8, -7, 18], [2, -7, 18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
   t.deepEqual(obs, exp)
 
   mirrored = mirrorX(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Y
@@ -94,10 +104,12 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[8, 7, -12], [8, -13, -12], [-2, -13, -12], [-2, 7, -12]],
     [[-2, -13, 18], [8, -13, 18], [8, 7, 18], [-2, 7, 18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorY(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // mirror about Z
@@ -111,10 +123,12 @@ test('mirror: mirroring of geom3 about X/Y/Z produces expected changes to polygo
     [[8, -7, 12], [8, 13, 12], [-2, 13, 12], [-2, -7, 12]],
     [[-2, 13, -18], [8, 13, -18], [8, -7, -18], [-2, -7, -18]]
   ]
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   mirrored = mirrorZ(geometry)
   obs = geom3.toPoints(mirrored)
+  t.notThrows(() => geom3.validate(mirrored))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -128,9 +142,11 @@ test('mirror: mirroring of multiple objects produces an array of mirrored object
 
   let obs = path2.toPoints(mirrored[1])
   let exp = [[-5, -5], [5, -5], [-5, 5], [10, 5]]
+  t.notThrows(() => path2.validate(mirrored[1]))
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(mirrored[2])
   exp = [[-5, 5], [0, -5], [10, 5]]
+  t.notThrows(() => geom2.validate(mirrored[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/operations/transforms/rotate.test.js

@@ -21,6 +21,7 @@ test('rotate: rotating of a path2 produces expected changes to points', (t) => {
 
   rotated = rotateZ(Math.PI / 2, geometry)
   obs = path2.toPoints(rotated)
+  t.notThrows(() => path2.validate(rotated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -35,10 +36,12 @@ test('rotate: rotating of a geom2 produces expected changes to points', (t) => {
     new Float32Array([0, -1]),
     new Float32Array([1, 0])
   ]
+  t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 
   rotated = rotateZ(-Math.PI / 2, geometry)
   obs = geom2.toPoints(rotated)
+  t.notThrows(() => geom2.validate(rotated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -70,10 +73,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-2, -18, -6.999999999999999], [8, -18, -6.999999999999999],
       [8, -18, 13.000000000000002], [-2, -18, 13.000000000000002]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateX(Math.PI / 2, geometry)
   obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // rotate about Y
@@ -93,6 +98,7 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[-18, -7, -1.999999999999999], [-18, -7, 8.000000000000002],
       [-18, 13, 8.000000000000002], [-18, 13, -1.999999999999999]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateY(-Math.PI / 2, geometry)
@@ -116,10 +122,12 @@ test('rotate: rotating of a geom3 produces expected changes to polygons', (t) =>
     [[2.000000000000001, 7, 18], [-7.999999999999999, 7.000000000000001, 18],
       [-8.000000000000002, -12.999999999999998, 18], [1.9999999999999984, -13, 18]]
   ]
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   rotated = rotateZ(Math.PI, geometry)
   obs = geom3.toPoints(rotated)
+  t.notThrows(() => geom3.validate(rotated))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -134,9 +142,11 @@ test('rotate: rotating of multiple objects produces expected changes', (t) => {
 
   const obs1 = path2.toPoints(rotated[1])
   const exp1 = [[-5, -5], [-5, 5], [5, -5], [5.000000000000001, 10]]
+  t.notThrows(() => path2.validate(rotated[1]))
   t.true(comparePoints(obs1, exp1))
 
   const obs2 = geom2.toPoints(rotated[2])
   const exp2 = [[5, -5], [-5, 3.061616997868383e-16], [5.000000000000001, 10]]
+  t.notThrows(() => geom2.validate(rotated[2]))
   t.true(comparePoints(obs2, exp2))
 })

package/src/operations/transforms/scale.test.js

@@ -13,20 +13,24 @@ test('scale: scaling of a path2 produces expected changes to points', (t) => {
   let scaled = scale([3], geometry)
   let obs = path2.toPoints(scaled)
   let exp = [[0, 4], [3, 0]]
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 0.5], geometry)
   obs = path2.toPoints(scaled)
   exp = [[0, 2], [1, 0]]
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleY(0.5, geometry)
   obs = path2.toPoints(scaled)
+  t.notThrows(() => path2.validate(scaled))
   t.true(comparePoints(obs, exp))
 })
 
@@ -37,20 +41,24 @@ test('scale: scaling of a geom2 produces expected changes to points', (t) => {
   let scaled = scale([3], geometry)
   let obs = geom2.toPoints(scaled)
   let exp = [[-3, 0], [3, 0], [0, 1]]
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   // scale Y
   scaled = scale([1, 3], geometry)
   obs = geom2.toPoints(scaled)
   exp = [[-1, 0], [1, 0], [0, 3]]
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 
   scaled = scaleY(3, geometry)
   obs = geom2.toPoints(scaled)
+  t.notThrows(() => geom2.validate(scaled))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,10 +84,12 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-6, -7, -12], [-6, 13, -12], [24, 13, -12], [24, -7, -12]],
     [[-6, -7, 18], [24, -7, 18], [24, 13, 18], [-6, 13, 18]]
   ]
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleX(3, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Y
@@ -97,6 +107,7 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
 
   scaled = scaleY(0.5, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // scale Z
@@ -110,10 +121,12 @@ test('scale: scaling of a geom3 produces expected changes to polygons', (t) => {
     [[-2, -7, -60], [-2, 13, -60], [8, 13, -60], [8, -7, -60]],
     [[-2, -7, 90], [8, -7, 90], [8, 13, 90], [-2, 13, 90]]
   ]
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   scaled = scaleZ(5, geometry)
   obs = geom3.toPoints(scaled)
+  t.notThrows(() => geom3.validate(scaled))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -128,9 +141,11 @@ test('scale: scaling of multiple objects produces expected changes', (t) => {
 
   const obs1 = path2.toPoints(scaled[1])
   const exp1 = [[-15, 5], [15, 5], [-15, -5], [30, -5]]
+  t.notThrows(() => path2.validate(scaled[1]))
   t.true(comparePoints(obs1, exp1))
 
   const obs2 = geom2.toPoints(scaled[2])
   const exp2 = [[-15, -5], [0, 5], [30, -5]]
+  t.notThrows(() => geom2.validate(scaled[2]))
   t.true(comparePoints(obs2, exp2))
 })

package/src/operations/transforms/transform.test.js

@@ -15,6 +15,7 @@ test('transform: transforming of a path2 produces expected changes to points', (
   geometry = transform(matrix, geometry)
   const obs = path2.toPoints(geometry)
   const exp = [[2, 2], [3, 2]]
+  t.notThrows(() => path2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -25,6 +26,7 @@ test('transform: transforming of a geom2 produces expected changes to sides', (t
   geometry = transform(matrix, geometry)
   const obs = geom2.toPoints(geometry)
   const exp = [[0, 0], [5, 0], [0, 5]]
+  t.notThrows(() => geom2.validate(geometry))
   t.true(comparePoints(obs, exp))
 })
 
@@ -49,6 +51,7 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
     [[-5, -10, -15], [-5, 10, -15], [5, 10, -15], [5, -10, -15]],
     [[-5, -10, 15], [5, -10, 15], [5, 10, 15], [-5, 10, 15]]
   ]
+  t.notThrows(() => geom3.validate(geometry))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -63,9 +66,11 @@ test('transform: transforming of multiple objects produces expected changes', (t
 
   let obs = path2.toPoints(transformed[1])
   let exp = [[-3, 7], [7, 7], [-3, -3], [12, -3]]
+  t.notThrows(() => path2.validate(transformed[1]))
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(transformed[2])
   exp = [[-3, -3], [2, 7], [12, -3]]
+  t.notThrows(() => geom2.validate(transformed[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/operations/transforms/translate.test.js

@@ -13,20 +13,24 @@ test('translate: translating of a path2 produces expected changes to points', (t
   let translated = translate([1], line)
   let obs = path2.toPoints(translated)
   let exp = [[1, 0], [2, 0]]
+  t.notThrows(() => path2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   translated = translateX(1, line)
   obs = path2.toPoints(translated)
+  t.notThrows(() => path2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   // translate Y
   translated = translate([0, 1], line)
   obs = path2.toPoints(translated)
   exp = [[0, 1], [1, 1]]
+  t.notThrows(() => path2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   translated = translateY(1, line)
   obs = path2.toPoints(translated)
+  t.notThrows(() => path2.validate(translated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -37,20 +41,24 @@ test('translate: translating of a geom2 produces expected changes to points', (t
   let translated = translate([1], geometry)
   let obs = geom2.toPoints(translated)
   let exp = [[1, 0], [2, 0], [1, 1]]
+  t.notThrows(() => geom2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   translated = translateX(1, geometry)
   obs = geom2.toPoints(translated)
+  t.notThrows(() => geom2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   // translate Y
   translated = translate([0, 1], geometry)
   obs = geom2.toPoints(translated)
   exp = [[0, 1], [1, 1], [0, 2]]
+  t.notThrows(() => geom2.validate(translated))
   t.true(comparePoints(obs, exp))
 
   translated = translateY(1, geometry)
   obs = geom2.toPoints(translated)
+  t.notThrows(() => geom2.validate(translated))
   t.true(comparePoints(obs, exp))
 })
 
@@ -76,10 +84,12 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[1, -7, -12], [1, 13, -12], [11, 13, -12], [11, -7, -12]],
     [[1, -7, 18], [11, -7, 18], [11, 13, 18], [1, 13, 18]]
   ]
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateX(3, geometry)
   obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translated Y
@@ -93,10 +103,12 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -4, -12], [-2, 16, -12], [8, 16, -12], [8, -4, -12]],
     [[-2, -4, 18], [8, -4, 18], [8, 16, 18], [-2, 16, 18]]
   ]
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateY(3, geometry)
   obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   // translate Z
@@ -110,10 +122,12 @@ test('translate: translating of a geom3 produces expected changes to polygons',
     [[-2, -7, -9], [-2, 13, -9], [8, 13, -9], [8, -7, -9]],
     [[-2, -7, 21], [8, -7, 21], [8, 13, 21], [-2, 13, 21]]
   ]
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 
   translated = translateZ(3, geometry)
   obs = geom3.toPoints(translated)
+  t.notThrows(() => geom3.validate(translated))
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
@@ -127,9 +141,11 @@ test('translate: translating of multiple objects produces expected changes', (t)
 
   let obs = path2.toPoints(translated[1])
   let exp = [[-2, 8], [8, 8], [-2, -2], [13, -2]]
+  t.notThrows(() => path2.validate(translated[1]))
   t.true(comparePoints(obs, exp))
 
   obs = geom2.toPoints(translated[2])
   exp = [[-2, -2], [3, 8], [13, -2]]
+  t.notThrows(() => geom2.validate(translated[2]))
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/arc.test.js

@@ -10,6 +10,7 @@ test('arc (defaults)', (t) => {
   const geometry = arc()
   const obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 33)
 })
 
@@ -37,6 +38,7 @@ test('arc (options)', (t) => {
   let geometry = arc({ center: [2, 2], segments: 16 })
   let obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
@@ -63,6 +65,7 @@ test('arc (options)', (t) => {
   geometry = arc({ radius: 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 17)
   t.true(comparePoints(obs, exp))
 
@@ -86,6 +89,7 @@ test('arc (options)', (t) => {
   geometry = arc({ startAngle: Math.PI / 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 14)
   t.true(comparePoints(obs, exp))
 
@@ -101,6 +105,7 @@ test('arc (options)', (t) => {
   geometry = arc({ endAngle: Math.PI / 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
@@ -129,6 +134,7 @@ test('arc (options)', (t) => {
   geometry = arc({ makeTangent: true, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 19)
   t.true(comparePoints(obs, exp))
 
@@ -147,6 +153,7 @@ test('arc (options)', (t) => {
   geometry = arc({ segments: 8 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 9)
   t.true(comparePoints(obs, exp))
 })
@@ -163,6 +170,7 @@ test('arc (rotations)', (t) => {
   let geometry = arc({ startAngle: Math.PI / 2, endAngle: Math.PI, segments: 16 })
   let obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 6)
   t.true(comparePoints(obs, exp))
 
@@ -181,6 +189,7 @@ test('arc (rotations)', (t) => {
   geometry = arc({ startAngle: Math.PI, endAngle: Math.PI * 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
@@ -199,6 +208,7 @@ test('arc (rotations)', (t) => {
   geometry = arc({ startAngle: Math.PI * 2 * 0.75, endAngle: Math.PI / 2, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 10)
   t.true(comparePoints(obs, exp))
 
@@ -206,6 +216,7 @@ test('arc (rotations)', (t) => {
   geometry = arc({ startAngle: Math.PI * 2 * 0.75, endAngle: 270.000000005 * 0.017453292519943295, segments: 16 })
   obs = path2.toPoints(geometry)
 
+  t.notThrows(() => path2.validate(geometry))
   t.deepEqual(obs.length, 1)
   t.true(comparePoints(obs, exp))
 })

package/src/primitives/circle.test.js

@@ -10,6 +10,7 @@ test('circle (defaults)', (t) => {
   const geometry = circle()
   const pts = geom2.toPoints(geometry)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 32)
 })
 
@@ -42,7 +43,7 @@ test('circle (options)', (t) => {
     [4.555504184431392, 3.5898563569410915],
     [5.160607986722184, 3.266421636210497],
     [5.817183872943549, 3.067251518588694],
-    [6.499999999999999, 3],
+    [6.5, 3],
     [7.182816127056449, 3.0672515185886935],
     [7.8393920132778145, 3.266421636210497],
     [8.444495815568606, 3.589856356941091],
@@ -52,6 +53,7 @@ test('circle (options)', (t) => {
     [9.932748481411306, 5.817183872943549]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 32)
   t.true(comparePoints(pts, exp))
 
@@ -63,20 +65,21 @@ test('circle (options)', (t) => {
     [3.2335783637895035, 1.3393920132778143],
     [2.4748737341529163, 2.474873734152916],
     [1.3393920132778145, 3.2335783637895035],
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [-1.339392013277814, 3.2335783637895035],
     [-2.474873734152916, 2.4748737341529163],
     [-3.2335783637895035, 1.3393920132778145],
-    [-3.5, 4.286263797015736e-16],
+    [-3.5, 0],
     [-3.233578363789504, -1.3393920132778139],
     [-2.474873734152917, -2.474873734152916],
     [-1.339392013277816, -3.233578363789503],
-    [-6.429395695523604e-16, -3.5],
+    [0, -3.5],
     [1.339392013277815, -3.233578363789503],
     [2.474873734152916, -2.474873734152917],
     [3.233578363789503, -1.3393920132778163]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 16)
   t.true(comparePoints(pts, exp))
 
@@ -84,22 +87,23 @@ test('circle (options)', (t) => {
   geometry = circle({ radius: 3.5, startAngle: Math.PI / 2, segments: 16 })
   pts = geom2.toPoints(geometry)
   exp = [
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [-1.339392013277814, 3.2335783637895035],
     [-2.474873734152916, 2.4748737341529163],
     [-3.2335783637895035, 1.3393920132778145],
-    [-3.5, 4.286263797015736e-16],
+    [-3.5, 0],
     [-3.233578363789504, -1.3393920132778139],
     [-2.474873734152917, -2.474873734152916],
     [-1.339392013277816, -3.233578363789503],
-    [-6.429395695523604e-16, -3.5],
+    [0, -3.5],
     [1.339392013277815, -3.233578363789503],
     [2.474873734152916, -2.474873734152917],
     [3.233578363789503, -1.3393920132778163],
-    [3.5, -8.572527594031472e-16],
+    [3.5, 0],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 14)
   t.true(comparePoints(pts, exp))
 
@@ -111,10 +115,11 @@ test('circle (options)', (t) => {
     [3.2335783637895035, 1.3393920132778143],
     [2.4748737341529163, 2.474873734152916],
     [1.3393920132778145, 3.2335783637895035],
-    [2.143131898507868e-16, 3.5],
+    [0, 3.5],
     [0, 0]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 6)
   t.true(comparePoints(pts, exp))
 
@@ -129,6 +134,7 @@ test('circle (options)', (t) => {
     [1.0815594803123152, -3.3286978070330377]
   ]
 
+  t.notThrows(() => geom2.validate(geometry))
   t.deepEqual(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })

package/src/primitives/cube.test.js

@@ -9,6 +9,7 @@ const comparePolygonsAsPoints = require('../../test/helpers/comparePolygonsAsPoi
 test('cube (defaults)', (t) => {
   const obs = cube()
   const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
 })
 
@@ -25,6 +26,7 @@ test('cube (options)', (t) => {
     [[3, 3, 10], [10, 3, 10], [10, 10, 10], [3, 10, 10]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -40,6 +42,7 @@ test('cube (options)', (t) => {
     [[-3.5, -3.5, 3.5], [3.5, -3.5, 3.5], [3.5, 3.5, 3.5], [-3.5, 3.5, 3.5]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/primitives/cuboid.js

@@ -43,7 +43,7 @@ const cuboid = (options) => {
         ]
         return pos
       })
-      return poly3.fromPoints(points)
+      return poly3.create(points)
     })
   )
   return result