@jscad/modeling 2.7.2 → 2.9.1

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/extrusions/slice/calculatePlane.js

@@ -23,10 +23,13 @@ const calculatePlane = (slice) => {
   let farthestEdge
   let distance = 0
   edges.forEach((edge) => {
-    const d = vec3.squaredDistance(midpoint, edge[0])
-    if (d > distance) {
-      farthestEdge = edge
-      distance = d
+    // Make sure that the farthest edge is not a self-edge
+    if (!vec3.equals(edge[0], edge[1])) {
+      const d = vec3.squaredDistance(midpoint, edge[0])
+      if (d > distance) {
+        farthestEdge = edge
+        distance = d
+      }
     }
   })
   // find the before edge

package/src/operations/extrusions/slice/isA.js

@@ -1,6 +1,6 @@
 /**
- * Determin if the given object is a slice.
- * @param {slice} object - the object to interogate
+ * Determine if the given object is a slice.
+ * @param {slice} object - the object to interrogate
  * @returns {Boolean} true if the object matches a slice
  * @alias module:modeling/extrusions/slice.isA
  */

package/src/operations/extrusions/slice/repairSlice.js

@@ -0,0 +1,47 @@
+const vec3 = require('../../../maths/vec3')
+
+/*
+ * Mend gaps in a 2D slice to make it a closed polygon
+ */
+const repairSlice = (slice) => {
+  if (!slice.edges) return slice
+  const vertexMap = {} // string key to vertex map
+  const edgeCount = {} // count of (in - out) edges
+  slice.edges.forEach((edge) => {
+    const inKey = edge[0].toString()
+    const outKey = edge[1].toString()
+    vertexMap[inKey] = edge[0]
+    vertexMap[outKey] = edge[1]
+    edgeCount[inKey] = (edgeCount[inKey] || 0) + 1 // in
+    edgeCount[outKey] = (edgeCount[outKey] || 0) - 1 // out
+  })
+  // find vertices which are missing in or out edges
+  const missingIn = Object.keys(edgeCount).filter((e) => edgeCount[e] < 0)
+  const missingOut = Object.keys(edgeCount).filter((e) => edgeCount[e] > 0)
+  // pairwise distance of bad vertices
+  missingIn.forEach((key1) => {
+    const v1 = vertexMap[key1]
+    // find the closest vertex that is missing an out edge
+    let bestDistance = Infinity
+    let bestReplacement
+    missingOut.forEach((key2) => {
+      const v2 = vertexMap[key2]
+      const distance = Math.hypot(v1[0] - v2[0], v1[1] - v2[1])
+      if (distance < bestDistance) {
+        bestDistance = distance
+        bestReplacement = v2
+      }
+    })
+    console.warn(`repairSlice: repairing vertex gap ${v1} to ${bestReplacement} distance ${bestDistance}`)
+    // merge broken vertices
+    slice.edges.forEach((edge) => {
+      if (edge[0].toString() === key1) edge[0] = bestReplacement
+      if (edge[1].toString() === key1) edge[1] = bestReplacement
+    })
+  })
+  // Remove self-edges
+  slice.edges = slice.edges.filter((e) => !vec3.equals(e[0], e[1]))
+  return slice
+}
+
+module.exports = repairSlice

package/src/operations/extrusions/slice/toPolygons.js

@@ -1,21 +1,6 @@
-const vec3 = require('../../../maths/vec3')
-
-const geom3 = require('../../../geometries/geom3')
 const poly3 = require('../../../geometries/poly3')
-
-const intersectGeom3Sub = require('../../booleans/intersectGeom3Sub')
-
-const calculatePlane = require('./calculatePlane')
-
-const toPolygon3D = (vector, edge) => {
-  const points = [
-    vec3.subtract(vec3.create(), edge[0], vector),
-    vec3.subtract(vec3.create(), edge[1], vector),
-    vec3.add(vec3.create(), edge[1], vector),
-    vec3.add(vec3.create(), edge[0], vector)
-  ]
-  return poly3.fromPoints(points)
-}
+const earcut = require('../earcut')
+const PolygonHierarchy = require('../earcut/polygonHierarchy')
 
 /**
  * Return a list of polygons which are enclosed by the slice.
@@ -24,52 +9,31 @@ const toPolygon3D = (vector, edge) => {
  * @alias module:modeling/extrusions/slice.toPolygons
  */
 const toPolygons = (slice) => {
-  const splane = calculatePlane(slice)
-
-  // find the midpoint of the slice, which will lie on the plane by definition
-  const edges = slice.edges
-  const midpoint = edges.reduce((point, edge) => vec3.add(vec3.create(), point, edge[0]), vec3.create())
-  vec3.scale(midpoint, midpoint, 1 / edges.length)
-
-  // find the farthest edge from the midpoint, which will be on an outside edge
-  let farthestEdge = [[NaN, NaN, NaN], [NaN, NaN, NaN]]
-  let distance = 0
-  edges.forEach((edge) => {
-    const d = vec3.squaredDistance(midpoint, edge[0])
-    if (d > distance) {
-      farthestEdge = edge
-      distance = d
+  const hierarchy = new PolygonHierarchy(slice)
+
+  const polygons = []
+  hierarchy.roots.forEach(({ solid, holes }) => {
+    // hole indices
+    let index = solid.length
+    const holesIndex = []
+    holes.forEach((hole, i) => {
+      holesIndex.push(index)
+      index += hole.length
+    })
+
+    // compute earcut triangulation for each solid
+    const vertices = [solid, ...holes].flat()
+    const data = vertices.flat()
+    // Get original 3D vertex by index
+    const getVertex = (i) => hierarchy.to3D(vertices[i])
+    const indices = earcut(data, holesIndex)
+    for (let i = 0; i < indices.length; i += 3) {
+      // Map back to original vertices
+      const tri = indices.slice(i, i + 3).map(getVertex)
+      polygons.push(poly3.fromPointsAndPlane(tri, hierarchy.plane))
     }
   })
 
-  // create one LARGE polygon to encompass the side, i.e. base
-  const direction = vec3.subtract(vec3.create(), farthestEdge[0], midpoint)
-  const perpendicular = vec3.cross(vec3.create(), splane, direction)
-
-  const p1 = vec3.add(vec3.create(), midpoint, direction)
-  vec3.add(p1, p1, direction)
-  const p2 = vec3.add(vec3.create(), midpoint, perpendicular)
-  vec3.add(p2, p2, perpendicular)
-  const p3 = vec3.subtract(vec3.create(), midpoint, direction)
-  vec3.subtract(p3, p3, direction)
-  const p4 = vec3.subtract(vec3.create(), midpoint, perpendicular)
-  vec3.subtract(p4, p4, perpendicular)
-  const poly1 = poly3.fromPoints([p1, p2, p3, p4])
-  const base = geom3.create([poly1])
-
-  const wallPolygons = edges.map((edge) => toPolygon3D(splane, edge))
-  const walls = geom3.create(wallPolygons)
-
-  // make an insection of the base and the walls, creating... a set of polygons!
-  const geometry3 = intersectGeom3Sub(base, walls)
-
-  // return only those polygons from the base
-  let polygons = geom3.toPolygons(geometry3)
-  polygons = polygons.filter((polygon) => {
-    const a = vec3.angle(splane, poly3.plane(polygon))
-    // walls should be PI / 2 radians rotated from the base
-    return Math.abs(a) < (Math.PI / 90)
-  })
   return polygons
 }
 

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,10 +42,11 @@ test('hull (single, geom2)', (t) => {
   obs = hull(geometry)
   pts = geom2.toPoints(obs)
 
+  t.notThrows(() => geom2.validate(geometry))
   t.is(pts.length, 7)
 })
 
-test('hull (multiple, overlaping, geom2)', (t) => {
+test('hull (multiple, overlapping, geom2)', (t) => {
   const geometry1 = geom2.fromPoints([[5, 5], [-5, 5], [-5, -5], [5, -5]])
   const geometry2 = geom2.fromPoints([[3, 3], [-3, 3], [-3, -3], [3, -3]])
   const geometry3 = geom2.fromPoints([[6, 3], [-6, 3], [-6, -3], [6, -3]])
@@ -66,23 +69,27 @@ test('hull (multiple, overlaping, 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.js

@@ -5,7 +5,7 @@ const union = require('../booleans/union')
 const hull = require('./hull')
 
 /**
- * Create a chain of hulled geometries from the given gemetries.
+ * Create a chain of hulled geometries from the given geometries.
  * Essentially hull A+B, B+C, C+D, etc., then union the results.
  * The given geometries should be of the same type, either geom2 or geom3 or path2.
  *

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/hullGeom2.js

@@ -30,7 +30,7 @@ const hullGeom2 = (...geometries) => {
 
   const hullpoints = hullPoints2(uniquepoints)
 
-  // NOTE: more then three points are required to create a new geometry
+  // NOTE: more than three points are required to create a new geometry
   if (hullpoints.length < 3) return geom2.create()
 
   // assemble a new geometry from the list of points

package/src/operations/hulls/hullPath2.js

@@ -1,7 +1,5 @@
 const flatten = require('../../utils/flatten')
 
-const vec2 = require('../../maths/vec2')
-
 const path2 = require('../../geometries/path2')
 
 const hullPoints2 = require('./hullPoints2')
@@ -16,11 +14,15 @@ const hullPath2 = (...geometries) => {
 
   // extract the unique points from the geometries
   const uniquepoints = []
+  const found = new Set()
   geometries.forEach((geometry) => {
     const points = path2.toPoints(geometry)
     points.forEach((point) => {
-      const index = uniquepoints.findIndex((unique) => vec2.equals(unique, point))
-      if (index < 0) uniquepoints.push(point)
+      const key = point.toString()
+      if (!found.has(key)) {
+        uniquepoints.push(point)
+        found.add(key)
+      }
     })
   })
 

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

@@ -0,0 +1,16 @@
+const test = require('ava')
+
+const { path2 } = require('../../geometries')
+
+const hullPath2 = require('./hullPath2')
+
+test('hullPath2', (t) => {
+  const closed = true
+  const geometry1 = path2.fromPoints({ closed }, [[0, 0], [-4, 4], [-4, -4]])
+  const geometry2 = path2.fromPoints({ closed }, [[0, 0], [4, -4], [4, 4]])
+
+  const obs = hullPath2(geometry1, geometry2)
+  t.notThrows(() => path2.validate(obs))
+  const pts = path2.toPoints(obs)
+  t.is(pts.length, 4)
+})

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

@@ -42,7 +42,7 @@ test('hullPoints2 bug #114 2 circles with 18 segments', (t) => {
     [7.298133329356933, -1.9283628290596186]
   ]
 
-  // we just want to bwe sure no err happens for this case
+  // we just want to be sure no err happens for this case
   const out = hullPoints2(points)
   t.is(out.length, 19)
 })

package/src/operations/modifiers/edges.js

@@ -149,7 +149,7 @@ const splitEdge = (openedges, edge, eps) => {
  */
 const cullOpenEdges = (edges) => {
   const openedges = []
-  edges.forEach((edge, i) => {
+  edges.forEach((edge) => {
     const polygons = edge.polygons
     if (polygons.length === 1) {
       // console.log('open edge: ',edge[0],'<-->',edge[1])

package/src/operations/modifiers/generalize.js

@@ -81,7 +81,7 @@ const generalize = (options, ...geometries) => {
   geometries = flatten(geometries)
   if (geometries.length === 0) throw new Error('wrong number of arguments')
 
-  const results = geometries.map((geometry, i) => {
+  const results = geometries.map((geometry) => {
     if (path2.isA(geometry)) return generalizePath2(options, geometry)
     if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
     if (geom3.isA(geometry)) return generalizeGeom3(options, geometry)

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/modifiers/snap.test.js

@@ -11,7 +11,7 @@ const { snap } = require('./index')
 test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry1 = path2.create()
   const geometry2 = arc({ radius: 1 / 2, segments: 8 })
-  const geometry3 = arc({ radius: 1.3333333333333333333 / 2, segments: 8 })
+  const geometry3 = arc({ radius: 1.3333333333333333 / 2, segments: 8 })
   const geometry4 = arc({ radius: Math.PI * 1000 / 2, segments: 8 })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
@@ -55,7 +55,7 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
 test('snap: snap of a geom2 produces an expected geom2', (t) => {
   const geometry1 = geom2.create()
   const geometry2 = rectangle({ size: [1, 1, 1] })
-  const geometry3 = rectangle({ size: [1.3333333333333333333, 1.3333333333333333333, 1.3333333333333333333] })
+  const geometry3 = rectangle({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
   const geometry4 = rectangle({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)
@@ -87,7 +87,7 @@ test('snap: snap of a geom2 produces an expected geom2', (t) => {
 test('snap: snap of a geom3 produces an expected geom3', (t) => {
   const geometry1 = geom3.create()
   const geometry2 = cuboid({ size: [1, 1, 1] })
-  const geometry3 = cuboid({ size: [1.3333333333333333333, 1.3333333333333333333, 1.3333333333333333333] })
+  const geometry3 = cuboid({ size: [1.3333333333333333, 1.3333333333333333, 1.3333333333333333] })
   const geometry4 = cuboid({ size: [Math.PI * 1000, Math.PI * 1000, Math.PI * 1000] })
 
   const results = snap(geometry1, geometry2, geometry3, geometry4)

package/src/operations/transforms/align.d.ts

@@ -7,7 +7,7 @@ type NullableNumber = null | number
 
 export interface AlignOptions {
   modes?: Array<'center' | 'max' | 'min' | 'none'>
-  relativeTo?: [NullableNumber] | [NullableNumber | NullableNumber] | [NullableNumber | NullableNumber | NullableNumber]
+  relativeTo?: [NullableNumber] | [NullableNumber, NullableNumber] | [NullableNumber, NullableNumber, NullableNumber]
   grouped?: boolean
 }
 

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))
 })