@jscad/modeling 2.9.0 → 2.9.1

package/src/operations/extrusions/extrudeFromSlices.test.js

@@ -36,6 +36,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   geometry3 = extrudeFromSlices({ }, poly2)
   pts = geom3.toPoints(geometry3)
 
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -68,6 +69,7 @@ test('extrudeFromSlices (torus)', (t) => {
     }, hex
   )
   const pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -86,6 +88,8 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
+  // expected to throw because capEnd is false (non-closed geometry)
+  t.throws(() => geom3.validate(geometry3))
   t.is(pts.length, 26)
 })
 
@@ -103,20 +107,21 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
     }, base
   )
   const pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 304)
 })
 
 test('extrudeFromSlices (holes)', (t) => {
   const geometry2 = geom2.create(
     [
-      [[-10.0, 10.0], [-10.0, -10.0]],
-      [[-10.0, -10.0], [10.0, -10.0]],
-      [[10.0, -10.0], [10.0, 10.0]],
-      [[10.0, 10.0], [-10.0, 10.0]],
-      [[-5.0, -5.0], [-5.0, 5.0]],
-      [[5.0, -5.0], [-5.0, -5.0]],
-      [[5.0, 5.0], [5.0, -5.0]],
-      [[-5.0, 5.0], [5.0, 5.0]]
+      [[-10, 10], [-10, -10]],
+      [[-10, -10], [10, -10]],
+      [[10, -10], [10, 10]],
+      [[10, 10], [-10, 10]],
+      [[-5, -5], [-5, 5]],
+      [[5, -5], [-5, -5]],
+      [[5, 5], [5, -5]],
+      [[-5, 5], [5, 5]]
     ]
   )
   const geometry3 = extrudeFromSlices({ }, geometry2)
@@ -155,6 +160,7 @@ test('extrudeFromSlices (holes)', (t) => {
     [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]],
     [[-10, -10, 0], [-10, 10, 0], [-5, -5, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/extrusions/extrudeLinear.test.js

@@ -25,6 +25,7 @@ test('extrudeLinear (defaults)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
     [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -48,6 +49,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
     [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -67,6 +69,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, -5, 0], [5, 5, 0], [-5, 5, 0]],
     [[-5, 5, 0], [-5, -5, 0], [5, -5, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -98,6 +101,7 @@ test('extrudeLinear (twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]],
     [[-5, -5, 0], [-5, 5, 0], [5, 5, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -138,19 +142,20 @@ test('extrudeLinear (twist)', (t) => {
 
   geometry3 = extrudeLinear({ height: 15, twistAngle: Math.PI / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 244)
 })
 
 test('extrudeLinear (holes)', (t) => {
   const geometry2 = geom2.create([
-    [[-5.00000, 5.00000], [-5.00000, -5.00000]],
-    [[-5.00000, -5.00000], [5.00000, -5.00000]],
-    [[5.00000, -5.00000], [5.00000, 5.00000]],
-    [[5.00000, 5.00000], [-5.00000, 5.00000]],
-    [[-2.00000, -2.00000], [-2.00000, 2.00000]],
-    [[2.00000, -2.00000], [-2.00000, -2.00000]],
-    [[2.00000, 2.00000], [2.00000, -2.00000]],
-    [[-2.00000, 2.00000], [2.00000, 2.00000]]
+    [[-5, 5], [-5, -5]],
+    [[-5, -5], [5, -5]],
+    [[5, -5], [5, 5]],
+    [[5, 5], [-5, 5]],
+    [[-2, -2], [-2, 2]],
+    [[2, -2], [-2, -2]],
+    [[2, 2], [2, -2]],
+    [[-2, 2], [2, 2]]
   ])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
   const pts = geom3.toPoints(geometry3)
@@ -188,6 +193,7 @@ test('extrudeLinear (holes)', (t) => {
     [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]],
     [[-5, -5, 0], [-5, 5, 0], [-2, -2, 0]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -195,7 +201,7 @@ test('extrudeLinear (holes)', (t) => {
 test('extrudeLinear (path2)', (t) => {
   const geometry2 = path2.fromPoints({ closed: true }, [[0, 0], [12, 0], [6, 10]])
   const geometry3 = extrudeLinear({ height: 15 }, geometry2)
-  t.true(geom3.isA(geometry3))
+  t.notThrows(() => geom3.validate(geometry3))
   const pts = geom3.toPoints(geometry3)
   const exp = [
     [[6, 10, 0], [0, 0, 0], [0, 0, 15]],

package/src/operations/extrusions/extrudeRectangular.test.js

@@ -12,10 +12,12 @@ test('extrudeRectangular (defaults)', (t) => {
 
   let obs = extrudeRectangular({ }, geometry1)
   let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 44)
 
   obs = extrudeRectangular({ }, geometry2)
   pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 32)
 })
 
@@ -25,10 +27,12 @@ test('extrudeRectangular (chamfer)', (t) => {
 
   let obs = extrudeRectangular({ corners: 'chamfer' }, geometry1)
   let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 60)
 
   obs = extrudeRectangular({ corners: 'chamfer' }, geometry2)
   pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 48)
 })
 
@@ -38,26 +42,29 @@ test('extrudeRectangular (segments = 8, round)', (t) => {
 
   let obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry1)
   let pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 84)
 
   obs = extrudeRectangular({ segments: 8, corners: 'round' }, geometry2)
   pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 64)
 })
 
 test('extrudeRectangular (holes)', (t) => {
   const geometry2 = geom2.create([
-    [[15.00000, 15.00000], [-15.00000, 15.00000]],
-    [[-15.00000, 15.00000], [-15.00000, -15.00000]],
-    [[-15.00000, -15.00000], [15.00000, -15.00000]],
-    [[15.00000, -15.00000], [15.00000, 15.00000]],
-    [[-5.00000, 5.00000], [5.00000, 5.00000]],
-    [[5.00000, 5.00000], [5.00000, -5.00000]],
-    [[5.00000, -5.00000], [-5.00000, -5.00000]],
-    [[-5.00000, -5.00000], [-5.00000, 5.00000]]
+    [[15, 15], [-15, 15]],
+    [[-15, 15], [-15, -15]],
+    [[-15, -15], [15, -15]],
+    [[15, -15], [15, 15]],
+    [[-5, 5], [5, 5]],
+    [[5, 5], [5, -5]],
+    [[5, -5], [-5, -5]],
+    [[-5, -5], [-5, 5]]
   ])
 
   const obs = extrudeRectangular({ size: 2, height: 15, segments: 16, corners: 'round' }, geometry2)
   const pts = geom3.toPoints(obs)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 192)
 })

package/src/operations/extrusions/extrudeRotate.test.js

@@ -11,6 +11,7 @@ test('extrudeRotate: (defaults) extruding of a geom2 produces an expected geom3'
 
   const geometry3 = extrudeRotate({ }, geometry2)
   const pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 96)
 })
 
@@ -34,15 +35,18 @@ test('extrudeRotate: (angle) extruding of a geom2 produces an expected geom3', (
     [[26, 4.898587196589413e-16, 8], [10, 4.898587196589413e-16, 8], [10, -4.898587196589413e-16, -8]],
     [[10, -4.898587196589413e-16, -8], [26, -4.898587196589413e-16, -8], [26, 4.898587196589413e-16, 8]]
   ]
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
   geometry3 = extrudeRotate({ segments: 4, angle: -250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 28)
 
   geometry3 = extrudeRotate({ segments: 4, angle: 250 * 0.017453292519943295 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 28)
 })
 
@@ -57,6 +61,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, 18.384776310850235, 8],
     [-11.803752993228215, 23.166169628897567, 8]
   ]
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 
@@ -67,6 +72,7 @@ test('extrudeRotate: (startAngle) extruding of a geom2 produces an expected geom
     [18.38477631085024, -18.384776310850235, 8],
     [23.166169628897567, 11.803752993228215, 8]
   ]
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 40)
   t.true(comparePoints(pts[0], exp))
 })
@@ -77,22 +83,26 @@ test('extrudeRotate: (segments) extruding of a geom2 produces an expected geom3'
   // test segments
   let geometry3 = extrudeRotate({ segments: 4 }, geometry2)
   let pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 32)
 
   geometry3 = extrudeRotate({ segments: 64 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 512)
 
   // test overlapping edges
   geometry2 = geom2.fromPoints([[0, 0], [2, 1], [1, 2], [1, 3], [3, 4], [0, 5]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 64)
 
   // test overlapping edges that produce hollow shape
   geometry2 = geom2.fromPoints([[30, 0], [30, 60], [0, 60], [0, 50], [10, 40], [10, 30], [0, 20], [0, 10], [10, 0]])
   geometry3 = extrudeRotate({ segments: 8 }, geometry2)
   pts = geom3.toPoints(geometry3)
+  t.notThrows.skip(() => geom3.validate(geometry3))
   t.is(pts.length, 80)
 })
 
@@ -112,6 +122,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[7, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8], [0, -4.898587196589413e-16, -8]],
     [[0, -4.898587196589413e-16, -8], [7, -4.898587196589413e-16, -8], [7, 4.898587196589413e-16, 8]]
   ]
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 8)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -140,6 +151,7 @@ test('extrudeRotate: (overlap +/-) extruding of a geom2 produces an expected geo
     [[2, 2.4492935982947064e-16, 4], [1, 4.898587196589413e-16, 8], [0, 4.898587196589413e-16, 8]],
     [[0, 4.898587196589413e-16, 8], [1, -4.898587196589413e-16, -8], [2, 2.4492935982947064e-16, 4]]
   ]
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 18)
   t.true(comparePolygonsAsPoints(pts, exp))
 })

package/src/operations/extrusions/project.test.js

@@ -16,14 +16,14 @@ test('project (defaults)', (t) => {
 
   const results = project({ }, geometry0, geometry1, geometry2, geometry3, geometry4)
   t.is(results.length, 5)
-  t.true(geom2.isA(results[0]))
-  t.true(geom2.isA(results[1]))
+  t.notThrows(() => geom2.validate(results[0]))
+  t.notThrows(() => geom2.validate(results[1]))
   t.is(results[2], geometry2)
   t.is(results[3], geometry3)
   t.is(results[4], geometry4)
 
   const result = project({ }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  t.notThrows(() => geom2.validate(result))
   const pts = geom2.toPoints(result)
   const exp = [
     [0, -2.9999933333333333],
@@ -40,7 +40,7 @@ test('project (defaults)', (t) => {
 
 test('project (X and Y axis)', (t) => {
   let result = project({ axis: [1, 0, 0], origin: [1, 0, 0] }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  t.notThrows(() => geom2.validate(result))
   let pts = geom2.toPoints(result)
   let exp = [
     [-1.0000200000000001, -3.999986666666667],
@@ -81,7 +81,7 @@ test('project (X and Y axis)', (t) => {
   t.true(comparePoints(pts, exp))
 
   result = project({ axis: [0, 1, 0], origin: [0, -1, 0] }, torus({ outerSegments: 4 }))
-  t.true(geom2.isA(result))
+  t.notThrows(() => geom2.validate(result))
   pts = geom2.toPoints(result)
   exp = [
     [3.999986666666667, -1.0000200000000001],

package/src/operations/hulls/hull.test.js

@@ -16,12 +16,14 @@ test('hull (single, geom2)', (t) => {
   let obs = hull(geometry)
   let pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 0)
 
   geometry = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 4)
 
   // convex C shape
@@ -40,6 +42,7 @@ test('hull (single, geom2)', (t) => {
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 7)
 })
 
@@ -66,23 +69,27 @@ test('hull (multiple, overlapping, geom2)', (t) => {
   let obs = hull(geometry1, geometry1)
   let pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // one inside another
   obs = hull(geometry1, geometry2)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // one overlapping another
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 8)
 
   obs = hull(geometry2, geometry4)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 7)
 })
 
@@ -108,22 +115,27 @@ test('hull (multiple, various, geom2)', (t) => {
 
   let obs = hull(geometry1, geometry2)
   let pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 8)
 })
 
@@ -133,6 +145,7 @@ test('hull (single, path2)', (t) => {
   let obs = hull(geometry)
   let pts = path2.toPoints(obs)
 
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 0)
 
   geometry = path2.fromPoints({}, [[0, 0], [5, 0], [5, 10], [4, 1]])
@@ -140,6 +153,7 @@ test('hull (single, path2)', (t) => {
   obs = hull(geometry)
   pts = path2.toPoints(obs)
 
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 3)
 })
 
@@ -165,22 +179,27 @@ test('hull (multiple, various, path2)', (t) => {
 
   let obs = hull(geometry1, geometry2)
   let pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry2, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 5)
 
   obs = hull(geometry1, geometry2, geometry3)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 6)
 
   obs = hull(geometry5, geometry4)
   pts = path2.toPoints(obs)
+  t.notThrows(() => path2.validate(obs))
   t.is(pts.length, 8)
 })
 
@@ -190,6 +209,7 @@ test('hull (single, geom3)', (t) => {
   let obs = hull(geometry)
   let pts = geom3.toPoints(obs)
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 0)
 
   geometry = sphere({ radius: 2, segments: 8 })
@@ -197,6 +217,7 @@ test('hull (single, geom3)', (t) => {
   obs = hull(geometry)
   pts = geom3.toPoints(obs)
 
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 32)
 })
 
@@ -214,6 +235,7 @@ test('hull (multiple, geom3)', (t) => {
     [[1, -1, 1], [-1, -1, 1], [-1, -1, -1], [1, -1, -1]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 6)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -236,6 +258,7 @@ test('hull (multiple, geom3)', (t) => {
     [[1, 1, -1], [6.5, 6.5, 3.5], [6.5, 3.5, 3.5], [1, -1, -1]]
   ]
 
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -248,6 +271,6 @@ test('hull (multiple, overlapping, geom3)', (t) => {
   const obs = hull(geometry1, geometry2, geometry3)
   const pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 160)
+  t.notThrows(() => geom3.validate(obs))
   t.is(pts.length, 92)
 })

package/src/operations/hulls/hullChain.test.js

@@ -12,12 +12,14 @@ test('hullChain (two, geom2)', (t) => {
   let obs = hullChain(geometry1, geometry1)
   let pts = geom2.toPoints(obs)
 
+    t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 4)
 
   // different
   obs = hullChain(geometry1, geometry2)
   pts = geom2.toPoints(obs)
 
+    t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 6)
 })
 
@@ -31,16 +33,16 @@ test('hullChain (three, geom2)', (t) => {
   let pts = geom2.toPoints(obs)
 
   // the sides change based on the bestplane chosen in trees/Node.js
+    t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 10)
-  // t.is(pts.length, 11)
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
   pts = geom2.toPoints(obs)
 
   // the sides change based on the bestplane chosen in trees/Node.js
+    t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 10)
-  // t.is(pts.length, 13)
 })
 
 test('hullChain (three, geom3)', (t) => {
@@ -73,13 +75,13 @@ test('hullChain (three, geom3)', (t) => {
   let obs = hullChain(geometry1, geometry2, geometry3)
   let pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 27)
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 23)
 
   // closed
   obs = hullChain(geometry1, geometry2, geometry3, geometry1)
   pts = geom3.toPoints(obs)
 
-  // t.is(pts.length, 45)
+  t.notThrows.skip(() => geom3.validate(obs))
   t.is(pts.length, 28)
 })

package/src/operations/hulls/hullPath2.test.js

@@ -10,7 +10,7 @@ test('hullPath2', (t) => {
   const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
 
   const obs = hullPath2(geometry1, geometry2)
-  t.true(path2.isA(obs))
+  t.notThrows(() => path2.validate(obs))
   const pts = path2.toPoints(obs)
   t.is(pts.length, 4)
 })

package/src/operations/modifiers/generalize.test.js

@@ -28,6 +28,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // apply snap only
@@ -47,6 +48,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707910908071407, -0.7854138713607164, 3.1415821816142815], [1.5707910908071407, -0.7854138713607164, 3.1415821816142815],
       [1.5707910908071407, 0.7854138713607164, 3.1415821816142815], [-1.5707910908071407, 0.7854138713607164, 3.1415821816142815]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // apply triangulate only
@@ -78,6 +80,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   const geometry2 = result // save the triangles for another test
@@ -99,6 +102,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, -0.7853981633974483, 3.141592653589793],
       [1.5707963267948966, 0.7853981633974483, 3.141592653589793], [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 
   // apply repairs only (triangles)
@@ -130,6 +134,7 @@ test('generalize: generalize of a geom3 produces an expected geom3', (t) => {
     [[-1.5707963267948966, -0.7853981633974483, 3.141592653589793], [1.5707963267948966, 0.7853981633974483, 3.141592653589793],
       [-1.5707963267948966, 0.7853981633974483, 3.141592653589793]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 })
 
@@ -190,5 +195,6 @@ test('generalize: generalize of a geom3 with T junctions produces an expected ge
     [[0, 1, 1], [-1, 1, 1], [0, 0, 1]],
     [[-1, 1, 1], [-1, 0, 1], [0, 0, 1]]
   ]
+  t.notThrows(() => geom3.validate(result))
   t.true(comparePolygonsAsPoints(pts, exp))
 })

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

@@ -1,6 +1,7 @@
 const test = require('ava')
 
 const { comparePoints } = require('../../../test/helpers')
+const { geom3 } = require('../../geometries')
 const { measureBoundingBox, measureAggregateBoundingBox } = require('../../measurements')
 const { cube } = require('../../primitives')
 
@@ -11,6 +12,7 @@ test('align: single object returns geometry unchanged if all axes are none', (t)
   const aligned = align({ modes: ['none', 'none', 'none'] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[8, 8, 8], [12, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -19,6 +21,7 @@ test('align: single objects returns geometry aligned, different modes on each ax
   const aligned = align({ modes: ['center', 'min', 'max'] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[-2, 0, -4], [2, 4, 0]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -27,6 +30,7 @@ test('align: unfilled modes and relativeTo arrays return results with expected v
   const aligned = align({ modes: ['center'], relativeTo: [0] }, original)
   const bounds = measureBoundingBox(aligned)
   const expectedBounds = [[-2, 8, 8], [2, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -38,6 +42,8 @@ test('align: multiple objects grouped returns geometry aligned, different modes
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [6, -10, 0], grouped: true }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[1.5, -10, -9], [10.5, -1, 0]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -49,6 +55,8 @@ test('align: multiple objects ungrouped returns geometry aligned, different mode
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [30, 30, 30] }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[28, 30, 26], [32, 34, 30]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -60,6 +68,8 @@ test('align: multiple objects grouped, relativeTo is nulls, returns geometry unc
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: true }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[3, 3, 3], [12, 12, 12]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })
 
@@ -71,6 +81,8 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
   const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, original)
   const bounds = measureAggregateBoundingBox(aligned)
   const expectedBounds = [[5.5, 3, 8], [9.5, 7, 12]]
+  t.notThrows(() => geom3.validate(aligned[0]))
+  t.notThrows(() => geom3.validate(aligned[1]))
   t.true(comparePoints(bounds, expectedBounds), 'Bounding box was not as expected. Result: ' + JSON.stringify(bounds))
 })