@jscad/modeling 2.9.0 → 2.9.3

package/src/operations/expansions/expandGeom3.test.js

@@ -6,20 +6,20 @@ const expandGeom3 = require('./expandGeom3')
 test('expandGeom3: expand completes properly, issue 876', async (t) => {
   setTimeout(() => t.fail(), 1000)
   const polies = [
-    poly3.fromPoints([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
-    poly3.fromPoints([[-16.863040644206997, -0.8000000000000015, -10.28], [-16.863040644206997, -2.7500000000000018, -10.28], [-14.292644267871385, -2.7500000000000018, -11.855000000000016], [-14.292644267871383, -0.8000000000000015, -11.855000000000018]]),
-    poly3.fromPoints([[-17.319999999999993, -0.8000000000000015, -9.999999999999996], [-17.319999999999993, -2.7500000000000018, -9.999999999999996], [-16.87560702649131, -2.7500000000000018, -10.272299999999998], [-16.866696319053347, -0.8000000000000015, -10.277759999999997]]),
-    poly3.fromPoints([[-16.863040644207004, -2.7500000000000013, -10.280000000000001], [-16.863040644207004, -0.8000000000000014, -10.280000000000001], [-16.86669631905335, -0.8000000000000012, -10.27776], [-16.875607026491313, -2.75, -10.272300000000001]]),
-    poly3.fromPoints([[-14.107140000000015, -0.7999999999999987, 11.85500000000003], [-14.107140000000015, -2.7499999999999982, 11.85500000000003], [-17.319999999999975, -2.7499999999999982, 9.999999999999956], [-17.319999999999975, -0.7999999999999987, 9.999999999999956]]),
-    poly3.fromPoints([[-17.32, -0.7999999999999988, 9.999999999999993], [-17.32, -0.7999999999999986, 11.855], [-14.107139999999994, -0.7999999999999986, 11.855]]),
-    poly3.fromPoints([[-17.32, -0.800000000000001, -11.855], [-17.32, -0.8000000000000008, -10.000000000000078], [-14.292644267871482, -0.800000000000001, -11.855]]),
-    poly3.fromPoints([[-17.32, -0.800000000000001, -11.855], [-19.61, -0.800000000000001, -11.855], [-19.61, -0.7999999999999986, 11.855], [-17.32, -0.7999999999999986, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.7500000000000013, -10.000000000000076], [-17.32, -2.7500000000000018, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855]]),
-    poly3.fromPoints([[-17.32, -2.7499999999999982, 11.855], [-17.32, -2.7499999999999987, 9.999999999999996], [-14.107139999999996, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-17.32, -2.7499999999999982, 11.855], [-19.61, -2.7499999999999982, 11.855], [-19.61, -2.7500000000000018, -11.855], [-17.32, -2.7500000000000018, -11.855]]),
-    poly3.fromPoints([[-14.107139999999996, -0.7999999999999986, 11.855], [-19.61, -0.7999999999999986, 11.855], [-19.61, -2.7499999999999982, 11.855], [-14.107139999999994, -2.7499999999999982, 11.855]]),
-    poly3.fromPoints([[-19.61, -0.8000000000000015, -11.855], [-14.292644267871486, -0.8000000000000015, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855], [-19.61, -2.7500000000000018, -11.855]])
+    poly3.create([[-19.61, -0.7999999999999986, 11.855], [-19.61, -0.8000000000000015, -11.855], [-19.61, -2.7500000000000018, -11.855], [-19.61, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.75, 10], [-17.32, -2.7500000000000013, -10], [-17.32, -0.8000000000000014, -10], [-17.32, -0.7999999999999987, 10]]),
+    poly3.create([[-16.863040644206997, -0.8000000000000015, -10.28], [-16.863040644206997, -2.7500000000000018, -10.28], [-14.292644267871385, -2.7500000000000018, -11.855000000000016], [-14.292644267871383, -0.8000000000000015, -11.855000000000018]]),
+    poly3.create([[-17.319999999999993, -0.8000000000000015, -9.999999999999996], [-17.319999999999993, -2.7500000000000018, -9.999999999999996], [-16.87560702649131, -2.7500000000000018, -10.272299999999998], [-16.866696319053347, -0.8000000000000015, -10.277759999999997]]),
+    poly3.create([[-16.863040644207004, -2.7500000000000013, -10.280000000000001], [-16.863040644207004, -0.8000000000000014, -10.280000000000001], [-16.86669631905335, -0.8000000000000012, -10.27776], [-16.875607026491313, -2.75, -10.272300000000001]]),
+    poly3.create([[-14.107140000000015, -0.7999999999999987, 11.85500000000003], [-14.107140000000015, -2.7499999999999982, 11.85500000000003], [-17.319999999999975, -2.7499999999999982, 9.999999999999956], [-17.319999999999975, -0.7999999999999987, 9.999999999999956]]),
+    poly3.create([[-17.32, -0.7999999999999988, 9.999999999999993], [-17.32, -0.7999999999999986, 11.855], [-14.107139999999994, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-17.32, -0.8000000000000008, -10.000000000000078], [-14.292644267871482, -0.800000000000001, -11.855]]),
+    poly3.create([[-17.32, -0.800000000000001, -11.855], [-19.61, -0.800000000000001, -11.855], [-19.61, -0.7999999999999986, 11.855], [-17.32, -0.7999999999999986, 11.855]]),
+    poly3.create([[-17.32, -2.7500000000000013, -10.000000000000076], [-17.32, -2.7500000000000018, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-17.32, -2.7499999999999987, 9.999999999999996], [-14.107139999999996, -2.7499999999999982, 11.855]]),
+    poly3.create([[-17.32, -2.7499999999999982, 11.855], [-19.61, -2.7499999999999982, 11.855], [-19.61, -2.7500000000000018, -11.855], [-17.32, -2.7500000000000018, -11.855]]),
+    poly3.create([[-14.107139999999996, -0.7999999999999986, 11.855], [-19.61, -0.7999999999999986, 11.855], [-19.61, -2.7499999999999982, 11.855], [-14.107139999999994, -2.7499999999999982, 11.855]]),
+    poly3.create([[-19.61, -0.8000000000000015, -11.855], [-14.292644267871486, -0.8000000000000015, -11.855], [-14.292644267871482, -2.7500000000000018, -11.855], [-19.61, -2.7500000000000018, -11.855]])
   ]
 
   const sub = geom3.create(polies)

package/src/operations/expansions/expandShell.js

@@ -10,7 +10,8 @@ const poly3 = require('../../geometries/poly3')
 
 const sphere = require('../../primitives/sphere')
 
-const retessellate = require('../booleans/retessellate')
+const retessellate = require('../modifiers/retessellate')
+
 const unionGeom3Sub = require('../booleans/unionGeom3Sub')
 
 const extrudePolygon = require('./extrudePolygon')
@@ -166,7 +167,7 @@ const expandShell = (options, geometry) => {
           startfacevertices.push(p1)
           endfacevertices.push(p2)
           const points = [prevp2, p2, p1, prevp1]
-          const polygon = poly3.fromPoints(points)
+          const polygon = poly3.create(points)
           polygons.push(polygon)
         }
         prevp1 = p1
@@ -174,8 +175,8 @@ const expandShell = (options, geometry) => {
       }
     }
     endfacevertices.reverse()
-    polygons.push(poly3.fromPoints(startfacevertices))
-    polygons.push(poly3.fromPoints(endfacevertices))
+    polygons.push(poly3.create(startfacevertices))
+    polygons.push(poly3.create(endfacevertices))
 
     const cylinder = geom3.create(polygons)
     result = unionGeom3Sub(result, cylinder)

package/src/operations/expansions/extrudePolygon.js

@@ -17,14 +17,14 @@ const extrudePolygon = (offsetvector, polygon1) => {
   const polygon2 = poly3.transform(mat4.fromTranslation(mat4.create(), offsetvector), polygon1)
   const numvertices = polygon1.vertices.length
   for (let i = 0; i < numvertices; i++) {
-    const sidefacepoints = []
     const nexti = (i < (numvertices - 1)) ? i + 1 : 0
-    sidefacepoints.push(polygon1.vertices[i])
-    sidefacepoints.push(polygon2.vertices[i])
-    sidefacepoints.push(polygon2.vertices[nexti])
-    sidefacepoints.push(polygon1.vertices[nexti])
-    const sidefacepolygon = poly3.fromPoints(sidefacepoints)
-    newpolygons.push(sidefacepolygon)
+    const sideFacePolygon = poly3.create([
+      polygon1.vertices[i],
+      polygon2.vertices[i],
+      polygon2.vertices[nexti],
+      polygon1.vertices[nexti]
+    ])
+    newpolygons.push(sideFacePolygon)
   }
   newpolygons.push(poly3.invert(polygon2))
 

package/src/operations/expansions/offset.test.js

@@ -12,6 +12,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   // offset it by 2.
   let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   let offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   let boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -19,6 +20,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   // offset it by -2.
   offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -27,6 +29,7 @@ test('offset: offsetting a straight line produces expected geometry', (t) => {
   linePath2 = path2.fromPoints({ closed: false }, points.reverse())
   offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 2)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [-2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -39,6 +42,7 @@ test('offset: offsetting a bent line produces expected geometry', (t) => {
   // offset it by 2.
   let offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   let offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 5)
   let boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [10, 8, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -46,6 +50,7 @@ test('offset: offsetting a bent line produces expected geometry', (t) => {
   // offset it by -2.
   offsetLinePath2 = offset({ delta: -2, corners: 'edge', segments: 8 }, linePath2)
   offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 5)
   boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[-2, 0, 0], [10, 12, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -56,6 +61,7 @@ test('offset: offsetting a 2 segment straight line produces expected geometry',
   const linePath2 = path2.fromPoints({ closed: false }, points)
   const offsetLinePath2 = offset({ delta: 2, corners: 'edge', segments: 8 }, linePath2)
   const offsetPoints = path2.toPoints(offsetLinePath2)
+  t.notThrows(() => path2.validate(offsetLinePath2))
   t.is(offsetPoints.length, 3)
   const boundingBox = measureBoundingBox(offsetLinePath2)
   t.true(comparePoints(boundingBox, [[2, 0, 0], [2, 10, 0]]), 'Unexpected bounding box: ' + JSON.stringify(boundingBox))
@@ -71,6 +77,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
   let pts = path2.toPoints(obs)
   let exp = [
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // expand +
@@ -82,6 +89,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [5.707106781186548, 0.7071067811865475],
     [0.7071067811865475, 5.707106781186548]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'chamfer' }, closeline)
@@ -94,6 +102,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [-1, 5],
     [-1, 6.123233995736766e-17]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // contract -
@@ -104,6 +113,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [2.5857864376269046, 1],
     [-0.7071067811865475, 4.292893218813452]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -1, corners: 'chamfer' }, closeline)
@@ -113,6 +123,7 @@ test('offset (corners: chamfer): offset of a path2 produces expected offset path
     [2.5857864376269046, 1],
     [0.9999999999999996, 2.585786437626905]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -132,6 +143,7 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [-1.9999999999999996, 6],
     [-5, 6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'edge' }, closeline)
@@ -146,6 +158,7 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [-6, 6],
     [-6, -6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -0.5, corners: 'edge' }, openline)
@@ -160,6 +173,7 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [-3.5, 4.5],
     [-5, 4.5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: -0.5, corners: 'edge' }, closeline)
@@ -174,6 +188,7 @@ test('offset (corners: edge): offset of a path2 produces expected offset path2',
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -209,6 +224,7 @@ test('offset (corners: round): offset of a path2 produces expected offset path2'
     [-3, 6],
     [-5, 6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   obs = offset({ delta: 1, corners: 'round', segments: 16 }, closeline)
@@ -247,6 +263,7 @@ test('offset (corners: round): offset of a path2 produces expected offset path2'
     [-6, 5],
     [-6, -5]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -289,6 +306,7 @@ test('offset (corners: round): offset of a CW path2 produces expected offset pat
     [5, -6],
     [-5, -6]
   ]
+  t.notThrows(() => path2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -301,6 +319,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
   let pts = geom2.toPoints(obs)
   let exp = [
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // expand +
@@ -322,6 +341,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-6, 5],
     [-6, -5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // contract -
@@ -339,6 +359,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // segments 1 - sharp points at corner
@@ -354,6 +375,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-6, 6],
     [-6, -6]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 
   // segments 16 - rounded corners
@@ -377,6 +399,7 @@ test('offset (options): offsetting of a simple geom2 produces expected offset ge
     [-3.5, 4.5],
     [-4.5, 4.5]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.true(comparePoints(pts, exp))
 })
 
@@ -429,6 +452,7 @@ test('offset (options): offsetting of a complex geom2 produces expected offset g
     [-4, -13],
     [-77, -77]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 20)
   t.true(comparePoints(pts, exp))
 })
@@ -473,6 +497,7 @@ test('offset (options): offsetting of round geom2 produces expected offset geom2
     [6.7105900605102855, -6.710590060510285],
     [8.767810140100096, -3.6317399864658024]
   ]
+  t.notThrows(() => geom2.validate(obs))
   t.is(pts.length, 16)
   t.true(comparePoints(pts, exp))
 })

package/src/operations/extrusions/earcut/assignHoles.js

@@ -31,6 +31,7 @@ const assignHoles = (geometry) => {
       solids.push(i)
     }
   })
+
   // for each hole, determine what solids it is inside of
   const children = [] // child holes of solid[i]
   const parents = [] // parent solids of hole[i]
@@ -47,19 +48,22 @@ const assignHoles = (geometry) => {
       }
     })
   })
+
   // check if holes have multiple parents and choose one with fewest children
   holes.forEach((h, j) => {
     // ensure at least one parent exists
     if (parents[j] && parents[j].length > 1) {
-      const parent = minIndex(parents[j], (p) => p.length)
+      // the solid directly containing this hole
+      const directParent = minIndex(parents[j], (p) => children[p].length)
       parents[j].forEach((p, i) => {
-        if (i !== parent) {
+        if (i !== directParent) {
           // Remove hole from skip level parents
-          children[p] = children[p].filter((c) => c !== j)
+          children[p] = children[p].filter((c) => c !== h)
         }
       })
     }
   })
+
   // map indices back to points
   return children.map((holes, i) => ({
     solid: outlines[solids[i]],

package/src/operations/extrusions/earcut/assignHoles.test.js

@@ -1,7 +1,7 @@
 const test = require('ava')
 
-const { subtract } = require('../../../operations/booleans')
-const rectangle = require('../../../primitives/rectangle')
+const { subtract, union } = require('../../../operations/booleans')
+const square = require('../../../primitives/square')
 const assignHoles = require('./assignHoles')
 
 test('slice: assignHoles() should return a polygon hierarchy', (t) => {
@@ -20,9 +20,55 @@ test('slice: assignHoles() should return a polygon hierarchy', (t) => {
     ]]
   }]
   const geometry = subtract(
-    rectangle({ size: [6, 6] }),
-    rectangle({ size: [4, 4] })
+    square({ size: 6 }),
+    square({ size: 4 })
   )
   const obs1 = assignHoles(geometry)
   t.deepEqual(obs1, exp1)
 })
+
+test('slice: assignHoles() should handle nested holes', (t) => {
+  const geometry = union(
+    subtract(
+      square({ size: 6 }),
+      square({ size: 4 })
+    ),
+    subtract(
+      square({ size: 10 }),
+      square({ size: 8 })
+    )
+  )
+  const obs1 = assignHoles(geometry)
+
+  const exp1 = [
+    {
+      solid: [
+        [-3.0000006060444444, -3.0000006060444444],
+        [3.0000006060444444, -3.0000006060444444],
+        [3.0000006060444444, 3.0000006060444444],
+        [-3.0000006060444444, 3.0000006060444444]
+      ],
+      holes: [[
+        [-2.0000248485333336, 2.0000248485333336],
+        [2.0000248485333336, 2.0000248485333336],
+        [2.0000248485333336, -2.0000248485333336],
+        [-2.0000248485333336, -2.0000248485333336]
+      ]]
+    },
+    {
+      solid: [
+        [-5.000025454577778, -5.000025454577778],
+        [5.000025454577778, -5.000025454577778],
+        [5.000025454577778, 5.000025454577778],
+        [-5.000025454577778, 5.000025454577778]
+      ],
+      holes: [[
+        [-3.9999763635555556, 3.9999763635555556],
+        [3.9999763635555556, 3.9999763635555556],
+        [3.9999763635555556, -3.9999763635555556],
+        [-3.9999763635555556, -3.9999763635555556]
+      ]]
+    }
+  ]
+  t.deepEqual(obs1, exp1)
+})

package/src/operations/extrusions/earcut/linkedList.js

@@ -1,7 +1,7 @@
 const sortLinked = require('./linkedListSort')
 
 class Node {
-  constructor(i, x, y) {
+  constructor (i, x, y) {
     // vertex index in coordinates array
     this.i = i
 

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

@@ -32,10 +32,11 @@ test('extrudeFromSlices (defaults)', (t) => {
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
-  const poly2 = poly3.fromPoints([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
+  const poly2 = poly3.create([[10, 10, 0], [-10, 10, 0], [-10, -10, 0], [10, -10, 0]])
   geometry3 = extrudeFromSlices({ }, poly2)
   pts = geom3.toPoints(geometry3)
 
+  t.notThrows(() => geom3.validate(geometry3))
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 })
@@ -44,7 +45,7 @@ test('extrudeFromSlices (torus)', (t) => {
   const sqrt3 = Math.sqrt(3) / 2
   const radius = 10
 
-  let hex = poly3.fromPoints([
+  let hex = poly3.create([
     [radius, 0, 0],
     [radius / 2, radius * sqrt3, 0],
     [-radius / 2, radius * sqrt3, 0],
@@ -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.js

@@ -114,7 +114,11 @@ const extrudeRotate = (options, geometry) => {
 
   const matrix = mat4.create()
   const createSlice = (progress, index, base) => {
-    const Zrotation = rotationPerSlice * index + startAngle
+    let Zrotation = rotationPerSlice * index + startAngle
+    // fix rounding error when rotating 2 * PI radians
+    if (totalRotation === Math.PI * 2 && index === segments) {
+      Zrotation = startAngle
+    }
     mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromXRotation(mat4.create(), Math.PI / 2))
 
     return slice.transform(matrix, base)