@jscad/modeling 3.0.4-alpha.0 → 3.0.6-alpha.0

package/src/operations/booleans/trees/splitPolygonByPlane.d.ts

@@ -28,6 +28,4 @@ interface SplitRes
 // In case the polygon is spanning, returns:
 // .front: a Polygon3 of the front part
 // .back: a Polygon3 of the back part
-declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;
-
-export default splitPolygonByPlane;
+export declare function splitPolygonByPlane(plane: Plane, polygon: Poly3): SplitRes;

package/src/operations/booleans/union.js

@@ -37,7 +37,7 @@ export const union = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  // if (path.isA(geometry)) return unionPath(matrix, geometries)
+  // TODO if (path2.isA(geometry)) return unionPath(geometries)
   if (geom2.isA(geometry)) return unionGeom2(geometries)
   if (geom3.isA(geometry)) return unionGeom3(geometries)
   throw new Error('union unsupported geometry type')

package/src/operations/extrusions/extrudeFromSlices.js

@@ -9,7 +9,7 @@ import { extrudeWalls } from './extrudeWalls.js'
 
 const defaultCallback = (progress, index, base) => {
   let baseSlice = null
-  if (geom2.isA(base)) baseSlice = slice.fromGeom2(base)
+  if (geom2.isA(base)) baseSlice = slice.fromOutlines(geom2.toOutlines(base))
   if (poly3.isA(base)) baseSlice = slice.fromVertices(poly3.toVertices(base))
 
   return progress === 0 || progress === 1 ? slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, progress]), baseSlice) : null

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

@@ -111,7 +111,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
       numberOfSlices: 5,
       callback: (progress, count, base) => {
         const newShape = circle({ radius: 5 + count, segments: 4 + count })
-        let newSlice = slice.fromGeom2(newShape)
+        let newSlice = slice.fromOutlines(geom2.toOutlines(newShape))
         newSlice = slice.transform(mat4.fromTranslation(mat4.create(), [0, 0, count * 10]), newSlice)
         return newSlice
       }

package/src/operations/extrusions/extrudeHelical.js

@@ -1,4 +1,5 @@
 import { TAU } from '../../maths/constants.js'
+import * as geom2 from '../../geometries/geom2/index.js'
 import * as slice from '../../geometries/slice/index.js'
 import * as mat4 from '../../maths/mat4/index.js'
 import { measureBoundingBox } from '../../measurements/measureBoundingBox.js'
@@ -45,7 +46,7 @@ export const extrudeHelical = (options, geometry) => {
 
   if (segmentsPerRotation < minNumberOfSegments) { throw new Error('The number of segments per rotation needs to be at least 3.') }
 
-  let baseSlice = slice.fromGeom2(geometry)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(geometry))
 
   const bounds = measureBoundingBox(geometry)
   if (bounds[1][0] <= 0) {

package/src/operations/extrusions/extrudeLinear.js

@@ -28,7 +28,7 @@ export const extrudeLinear = (options, ...objects) => {
   }
   const { height, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
-  options = { offset: [0, 0, height], twistAngle, twistSteps, repair }
+  options = { height, twistAngle, twistSteps, repair, offset: [0, 0, height] }
 
   const results = objects.map((object) => {
     if (path2.isA(object)) return extrudeLinearPath2(options, object)

package/src/operations/extrusions/extrudeLinearGeom2.js

@@ -1,8 +1,11 @@
 import * as mat4 from '../../maths/mat4/index.js'
 import * as vec3 from '../../maths/vec3/index.js'
 
+import * as geom2 from '../../geometries/geom2/index.js'
 import * as slice from '../../geometries/slice/index.js'
 
+import { isNumberArray } from '../../primitives/commonChecks.js'
+
 import { extrudeFromSlices } from './extrudeFromSlices.js'
 
 /*
@@ -25,6 +28,7 @@ export const extrudeLinearGeom2 = (options, geometry) => {
   }
   let { offset, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
+  if (!isNumberArray(offset, 3)) throw new Error('offset must be an array of three numbers')
   if (twistSteps < 1) throw new Error('twistSteps must be 1 or more')
 
   if (twistAngle === 0) {
@@ -32,18 +36,18 @@ export const extrudeLinearGeom2 = (options, geometry) => {
   }
 
   // convert to vector in order to perform transforms
-  const offsetV = vec3.clone(offset)
-
-  let baseSlice = slice.fromGeom2(geometry)
-  if (offsetV[2] < 0) baseSlice = slice.reverse(baseSlice)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(geometry))
+  if (offset[2] < 0) baseSlice = slice.reverse(baseSlice)
 
-  const matrix = mat4.create()
+  const matrix1 = mat4.create()
+  const matrix2 = mat4.create()
+  const offset1 = vec3.create()
   const createTwist = (progress, index, base) => {
     const Zrotation = index / twistSteps * twistAngle
-    const Zoffset = vec3.scale(vec3.create(), offsetV, index / twistSteps)
-    mat4.multiply(matrix, mat4.fromZRotation(matrix, Zrotation), mat4.fromTranslation(mat4.create(), Zoffset))
+    const Zoffset = vec3.scale(offset1, offset, index / twistSteps)
+    mat4.multiply(matrix1, mat4.fromZRotation(matrix1, Zrotation), mat4.fromTranslation(matrix2, Zoffset))
 
-    return slice.transform(matrix, base)
+    return slice.transform(matrix1, base)
   }
 
   options = {

package/src/operations/extrusions/extrudeRotate.js

@@ -106,7 +106,7 @@ export const extrudeRotate = (options, geometry) => {
 
   const rotationPerSlice = totalRotation / segments
   const isCapped = Math.abs(totalRotation) < TAU
-  let baseSlice = slice.fromGeom2(sliceGeometry)
+  let baseSlice = slice.fromOutlines(geom2.toOutlines(sliceGeometry))
   baseSlice = slice.reverse(baseSlice)
 
   const matrix = mat4.create()

package/src/operations/hulls/hull.js

@@ -42,9 +42,10 @@ export const hull = (...geometries) => {
   }
 
   const geometry = geometries[0]
-  if (path2.isA(geometry)) return hullPath2(geometries)
-  if (geom2.isA(geometry)) return hullGeom2(geometries)
   if (geom3.isA(geometry)) return hullGeom3(geometries)
+  if (geom2.isA(geometry)) return hullGeom2(geometries)
+  if (path2.isA(geometry)) return hullPath2(geometries)
+  // FIXME return geom3? if (path3.isA(geometry)) return hullPath3(geometries)
 
   // FIXME should this throw an error for unknown geometries?
   return geometry

package/src/operations/hulls/quickhull/Face.js

@@ -308,9 +308,14 @@ export class Face {
     const e2 = new HalfEdge(v2, face)
 
     // join edges
-    e0.next = e2.prev = e1
-    e1.next = e0.prev = e2
-    e2.next = e1.prev = e0
+    e0.next = e1
+    e2.prev = e1
+
+    e1.next = e2
+    e0.prev = e2
+
+    e2.next = e0
+    e1.prev = e0
 
     // main half edge reference
     face.edge = e0

package/src/operations/hulls/quickhull/QuickHull.js

@@ -118,6 +118,7 @@ export class QuickHull {
       end.next = null
       return face.outside
     }
+    return undefined
   }
 
   /**
@@ -215,11 +216,13 @@ export class QuickHull {
 
     // initially assume that the first vertex is the min/max
     for (i = 0; i < 3; i += 1) {
-      minVertices[i] = maxVertices[i] = this.vertices[0]
+      minVertices[i] = this.vertices[0]
+      maxVertices[i] = this.vertices[0]
     }
     // copy the coordinates of the first vertex to min/max
     for (i = 0; i < 3; i += 1) {
-      min[i] = max[i] = this.vertices[0].point[i]
+      min[i] = this.vertices[0].point[i]
+      max[i] = this.vertices[0].point[i]
     }
 
     // compute the min/max vertex on all 6 directions
@@ -456,6 +459,7 @@ export class QuickHull {
       }
       return eyeVertex
     }
+    return undefined
   }
 
   /**
@@ -477,7 +481,8 @@ export class QuickHull {
 
     let edge
     if (!crossEdge) {
-      edge = crossEdge = face.getEdge(0)
+      crossEdge = face.getEdge(0)
+      edge = crossEdge
     } else {
       // start from the next edge since `crossEdge` was already analyzed
       // (actually `crossEdge.opposite` was the face who called this method
@@ -722,7 +727,7 @@ export class QuickHull {
     for (let i = 0; i < this.newFaces.length; i += 1) {
       const face = this.newFaces[i]
       if (face.mark === VISIBLE) {
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {} // eslint-disable-line no-empty
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX_WRT_LARGER_FACE)) {}
       }
     }
 
@@ -733,7 +738,7 @@ export class QuickHull {
       const face = this.newFaces[i]
       if (face.mark === NON_CONVEX) {
         face.mark = VISIBLE
-        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {} // eslint-disable-line no-empty
+        while (this.doAdjacentMerge(face, MERGE_NON_CONVEX)) {}
       }
     }
 

package/src/operations/hulls/quickhull/VertexList.js

@@ -11,7 +11,8 @@ export class VertexList {
   }
 
   clear () {
-    this.head = this.tail = null
+    this.head = null
+    this.tail = null
   }
 
   /**

package/src/operations/hulls/toUniquePoints.js

@@ -1,6 +1,7 @@
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
 
 /*
  * Return the unique vertices of a geometry
@@ -25,6 +26,8 @@ export const toUniquePoints = (geometries) => {
       geom3.toVertices(geometry).forEach((vertices) => vertices.forEach(addPoint))
     } else if (path2.isA(geometry)) {
       path2.toPoints(geometry).forEach(addPoint)
+    } else if (path3.isA(geometry)) {
+      path3.toVertices(geometry).forEach(addPoint)
     }
   })
 

package/src/operations/modifiers/generalize.js

@@ -3,6 +3,8 @@ import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 import { snapPolygons } from './snapPolygons.js'
 import { mergePolygons } from './mergePolygons.js'
@@ -13,6 +15,10 @@ import { triangulatePolygons } from './triangulatePolygons.js'
  */
 const generalizePath2 = (options, geometry) => geometry
 
+/*
+ */
+const generalizePath3 = (options, geometry) => geometry
+
 /*
  */
 const generalizeGeom2 = (options, geometry) => geometry
@@ -66,9 +72,10 @@ const generalizeGeom3 = (options, geometry) => {
  */
 export const generalize = (options, ...geometries) => {
   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)
+    if (geom2.isA(geometry)) return generalizeGeom2(options, geometry)
+    if (path2.isA(geometry)) return generalizePath2(options, geometry)
+    if (path3.isA(geometry)) return generalizePath3(options, geometry)
     if (Array.isArray(geometry)) return generalize(options, ...geometry)
     return geometry
   })

package/src/operations/modifiers/reTesselateCoplanarPolygons.js

@@ -317,8 +317,8 @@ export const reTesselateCoplanarPolygons = (sourcePolygons) => {
           const vertices3d = points2d.map((point2d) => orthonormalFormula.to3D(point2d))
           const polygon = poly3.fromVerticesAndPlane(vertices3d, plane) // TODO support shared
 
-          // if we let empty polygon out, next retesselate will crash
-          if (polygon.vertices.length) destPolygons.push(polygon)
+          // if we let invalid polygons out, next retesselate will crash
+          if (polygon.vertices.length > 2) destPolygons.push(polygon)
         }
       }
     } // if(yIndex > 0)

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

@@ -66,7 +66,9 @@ test('retessellateCoplanarPolygons: should merge coplanar polygons', (t) => {
   polyL = translatePoly3([-15, -15, -15], polyE)
 
   obs = reTesselateCoplanarPolygons([polyH, polyI, polyJ, polyK, polyL])
-  t.is(obs.length, 1)
+  obs.forEach((polygon) => {
+    poly3.validate(polygon)
+  })
 })
 
 // Test for mark-and-filter optimization: multiple polygons that reach their
@@ -85,9 +87,8 @@ test('retessellateCoplanarPolygons: should correctly handle multiple polygon rem
   // Each triangle should be preserved (they don't overlap)
   t.is(obs.length, 3)
 
-  // Verify each polygon has 3 vertices (triangles)
   obs.forEach((polygon) => {
-    t.is(polygon.vertices.length, 3)
+    poly3.validate(polygon)
   })
 })
 
@@ -103,3 +104,28 @@ test('retessellateCoplanarPolygons: should merge adjacent polygons with shared e
   t.is(obs.length, 1)
   t.is(obs[0].vertices.length, 4) // rectangle has 4 vertices
 })
+
+test('retessellateCoplanarPolygons: should not return invalid polygons', (t) => {
+  const polyA = poly3.create([
+    [ 3.72172376113686, -3.7661089598376325, 13 ],
+    [ 3.72172376113686, -3.7661089598376325, 13.515937566757202 ],
+    [ 3.721663581864801, -3.766195461144145, 13.515937566757202 ]
+  ])
+  const polyB = poly3.create([
+    [ 3.721663581864801, -3.766195461144145, 13.0084828728813 ],
+    [ 3.721663581864801, -3.766195461144145, 13.00100040435791 ],
+    [ 3.721716664059388, -3.7661191611320772, 13.00100040435791 ]
+  ])
+  const polyC = poly3.create([
+    [ 3.721663581864801, -3.766195461144145, 13.515937566757202 ],
+    [ 3.721663581864801, -3.766195461144145, 13.0084828728813 ],
+    [ 3.7217166640593886, -3.766119161132077, 13.00100040435791 ],
+    [ 3.7217236444490864, -3.766109127563903, 13.00100040435791 ]
+  ])
+  const obs = reTesselateCoplanarPolygons([polyA, polyB, polyC])
+  t.is(obs.length, 1)
+
+  obs.forEach((polygon) => {
+    poly3.validate(polygon)
+  })
+})

package/src/operations/modifiers/retessellate.js

@@ -18,6 +18,7 @@ export const retessellate = (geometry) => {
     return geometry
   }
 
+  // FIXME this is creating new polygons
   const polygons = geom3.toPolygons(geometry).map((polygon, index) => ({ vertices: polygon.vertices, plane: poly3.plane(polygon), index: index }))
   const classified = classifyPolygons(polygons)
 

package/src/operations/modifiers/snap.js

@@ -1,22 +1,38 @@
 import * as vec2 from '../../maths/vec2/index.js'
+import * as vec3 from '../../maths/vec3/index.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
 import * as poly2 from '../../geometries/poly2/index.js'
 
 import { measureEpsilon } from '../../measurements/measureEpsilon.js'
 
 import { snapPolygons } from './snapPolygons.js'
 
+/*
+ */
 const snapPath2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const points = path2.toPoints(geometry)
   const newPoints = points.map((point) => vec2.snap(vec2.create(), point, epsilon))
   // snap can produce duplicate points, remove those
-  return path2.create(newPoints)
+  return path2.fromPoints({ closed: geometry.isClosed }, newPoints)
+}
+
+/*
+ */
+const snapPath3 = (geometry) => {
+  const epsilon = measureEpsilon(geometry)
+  const vertices = path3.toVertices(geometry)
+  const newVertices = vertices.map((vertice) => vec3.snap(vec3.create(), vertice, epsilon))
+  // snap can produce duplicate points, remove those
+  return path3.fromVertices({ closed: geometry.isClosed }, newVertices)
 }
 
+/*
+ */
 const snapGeom2 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const outlines = geom2.toOutlines(geometry)
@@ -38,6 +54,8 @@ const snapGeom2 = (geometry) => {
   return geom2.create(newOutlines)
 }
 
+/*
+ */
 const snapGeom3 = (geometry) => {
   const epsilon = measureEpsilon(geometry)
   const polygons = geom3.toPolygons(geometry)
@@ -54,9 +72,10 @@ const snapGeom3 = (geometry) => {
  */
 export const snap = (...geometries) => {
   const results = geometries.map((geometry) => {
-    if (path2.isA(geometry)) return snapPath2(geometry)
-    if (geom2.isA(geometry)) return snapGeom2(geometry)
     if (geom3.isA(geometry)) return snapGeom3(geometry)
+    if (geom2.isA(geometry)) return snapGeom2(geometry)
+    if (path2.isA(geometry)) return snapPath2(geometry)
+    if (path3.isA(geometry)) return snapPath3(geometry)
     if (Array.isArray(geometry)) return snap(...geometry)
     return geometry
   })

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

@@ -15,9 +15,10 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
   const geometry2 = arc({ radius: 1 / 2, segments: 8 })
   const geometry3 = arc({ radius: 1.3333333333333333 / 2, segments: 8 })
   const geometry4 = arc({ radius: TAU / 4 * 1000, segments: 8 })
+  const geometry5 = path2.fromPoints({ closed: true }, [[0, 0], [2, 2], [4, 0]])
 
-  const results = snap(geometry1, geometry2, geometry3, geometry4)
-  t.is(results.length, 4)
+  const results = snap(geometry1, geometry2, geometry3, geometry4, geometry5)
+  t.is(results.length, 5)
 
   let pts = path2.toPoints(results[0])
   let exp = []
@@ -61,6 +62,15 @@ test('snap: snap of a path2 produces an expected path2', (t) => {
     [1110.7100826766714, -1110.7100826766714]
   ]
   t.true(comparePoints(pts, exp))
+
+  t.true(results[4].isClosed)
+  pts = path2.toPoints(results[4])
+  exp = [
+    [0, 0],
+    [2.00001, 2.00001],
+    [3.9999900000000004, 0]
+  ]
+  t.true(comparePoints(pts, exp))
 })
 
 test('snap: snap of a geom2 produces an expected geom2', (t) => {

package/src/operations/offsets/offsetGeom3.test.js

@@ -91,6 +91,6 @@ test('offsetGeom3: offset completes properly, issue 876', (t) => {
 
   const obs = offset({ delta: 1.3, corners: 'round', segments: 12 }, sub)
   t.notThrows.skip(() => geom3.validate(obs))
-  t.is(measureArea(obs), 524.9674760547548)
-  t.is(measureVolume(obs), 604.0599465573156)
+  t.is(measureArea(obs), 524.9674756919702)
+  t.is(measureVolume(obs), 604.0599468042326)
 })

package/src/operations/transforms/align.js

@@ -76,12 +76,13 @@ export const align = (options, ...geometries) => {
   options = validateOptions(options)
   let { modes, relativeTo, grouped } = options
 
+  geometries = coalesce(geometries)
+
   if (relativeTo.filter((val) => val == null).length) {
     const bounds = measureAggregateBoundingBox(geometries)
     relativeTo = populateRelativeToFromBounds(relativeTo, modes, bounds)
   }
   if (grouped) {
-    geometries = coalesce(geometries)
     geometries = alignGeometries(geometries, modes, relativeTo)
   } else {
     geometries = geometries.map((geometry) => alignGeometries(geometry, modes, relativeTo))

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

@@ -79,7 +79,7 @@ test('align: multiple objects ungrouped, relativeTo is nulls, returns geometry a
     cube({ size: 2, center: [4, 4, 4] }),
     cube({ size: 4, center: [10, 10, 10] })
   ]
-  const aligned = align({ modes: ['center', 'min', 'max'], relativeTo: [null, null, null], grouped: false }, ...original)
+  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]))

package/src/operations/transforms/mirror.js

@@ -4,6 +4,8 @@ import * as plane from '../../maths/plane/index.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Mirror the given objects using the given options.
@@ -33,9 +35,11 @@ export const mirror = (options, ...objects) => {
   const matrix = mat4.mirrorByPlane(mat4.create(), planeOfMirror)
 
   const results = objects.map((object) => {
-    if (path2.isA(object)) return path2.transform(matrix, object)
-    if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return mirror(options, ...object)
     return object

package/src/operations/transforms/rotate.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Rotate the given objects using the given options.
@@ -28,9 +30,11 @@ export const rotate = (angles, ...objects) => {
   const matrix = mat4.fromTaitBryanRotation(mat4.create(), yaw, pitch, roll)
 
   const results = objects.map((object) => {
-    if (path2.isA(object)) return path2.transform(matrix, object)
-    if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return rotate(angles, ...object)
     return object

package/src/operations/transforms/scale.js

@@ -3,6 +3,8 @@ import * as mat4 from '../../maths/mat4/index.js'
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Scale the given objects using the given options.
@@ -26,9 +28,11 @@ export const scale = (factors, ...objects) => {
   const matrix = mat4.fromScaling(mat4.create(), factors)
 
   const results = objects.map((object) => {
-    if (path2.isA(object)) return path2.transform(matrix, object)
-    if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return scale(factors, ...object)
     return object

package/src/operations/transforms/transform.js

@@ -1,6 +1,8 @@
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
 import * as path2 from '../../geometries/path2/index.js'
+import * as path3 from '../../geometries/path3/index.js'
+import * as slice from '../../geometries/slice/index.js'
 
 /**
  * Transform the given objects using the given matrix.
@@ -16,9 +18,11 @@ export const transform = (matrix, ...objects) => {
   // TODO how to check that the matrix is REAL?
 
   const results = objects.map((object) => {
-    if (path2.isA(object)) return path2.transform(matrix, object)
-    if (geom2.isA(object)) return geom2.transform(matrix, object)
     if (geom3.isA(object)) return geom3.transform(matrix, object)
+    if (geom2.isA(object)) return geom2.transform(matrix, object)
+    if (path2.isA(object)) return path2.transform(matrix, object)
+    if (path3.isA(object)) return path3.transform(matrix, object)
+    if (slice.isA(object)) return slice.transform(matrix, object)
     // handle recursive arrays
     if (Array.isArray(object)) return transform(matrix, ...object)
     return object

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

@@ -4,11 +4,11 @@ import { comparePoints, comparePolygonsAsPoints } from '../../../test/helpers/in
 
 import { mat4 } from '../../maths/index.js'
 
-import { geom2, geom3, path2 } from '../../geometries/index.js'
+import { geom2, geom3, path2, path3 } from '../../geometries/index.js'
 
 import { transform } from './index.js'
 
-test('transform: transforming of a path2 produces expected changes to points', (t) => {
+test('transform: (path2)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 0])
   let geometry = path2.fromPoints({}, [[0, 0], [1, 0]])
 
@@ -19,7 +19,18 @@ test('transform: transforming of a path2 produces expected changes to points', (
   t.true(comparePoints(obs, exp))
 })
 
-test('transform: transforming of a geom2 produces expected changes to sides', (t) => {
+test('transform: (path3)', (t) => {
+  const matrix = mat4.fromTranslation(mat4.create(), [2, 2, 2])
+  let geometry = path3.fromVertices({ closed: true }, [[0, 0, 0], [1, 0, 1], [3, 2, 1]])
+
+  geometry = transform(matrix, geometry)
+  const obs = path3.toVertices(geometry)
+  const exp = [[2, 2, 2], [3, 2, 3], [5, 4, 3]]
+  t.notThrows(() => path3.validate(geometry))
+  t.true(comparePoints(obs, exp))
+})
+
+test('transform: (geom2)', (t) => {
   const matrix = mat4.fromScaling(mat4.create(), [5, 5, 5])
   let geometry = geom2.create([[[0, 0], [1, 0], [0, 1]]])
 
@@ -30,7 +41,7 @@ test('transform: transforming of a geom2 produces expected changes to sides', (t
   t.true(comparePoints(obs, exp))
 })
 
-test('transform: transforming of a geom3 produces expected changes to polygons', (t) => {
+test('transform: (geom3)', (t) => {
   const matrix = mat4.fromTranslation(mat4.create(), [-3, -3, -3])
   const points = [
     [[-2, -7, -12], [-2, -7, 18], [-2, 13, 18], [-2, 13, -12]],
@@ -55,7 +66,7 @@ test('transform: transforming of a geom3 produces expected changes to polygons',
   t.true(comparePolygonsAsPoints(obs, exp))
 })
 
-test('transform: transforming of multiple objects produces expected changes', (t) => {
+test('transform: (multiple objects)', (t) => {
   const junk = 'hello'
   const geometry1 = path2.fromPoints({}, [[-5, 5], [5, 5], [-5, -5], [10, -5]])
   const geometry2 = geom2.create([[[-5, -5], [0, 5], [10, -5]]])