@jscad/modeling 3.0.0-alpha.0 → 3.0.1-alpha.0

package/src/operations/booleans/subtract.js

@@ -1,5 +1,5 @@
 import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
-import { flatten } from '../../utils/flatten.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -13,11 +13,11 @@ import { subtractGeom3 } from './subtractGeom3.js'
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {Geom2|geom3} a new geometry
+ * @returns {Geom2|Geom3} a new geometry
  * @alias module:modeling/booleans.subtract
  *
  * @example
- * let myshape = subtract(cuboid({size: [5,5,5]}), cuboid({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = subtract(cuboid({size: 5}), cuboid({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+            +-------+
@@ -30,9 +30,9 @@ import { subtractGeom3 } from './subtractGeom3.js'
  *      +-------+
  */
 export const subtract = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('subtract wrong number of arguments')
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('subtract arguments must be the same geometry type')
   }

package/src/operations/booleans/subtract.test.js

@@ -4,11 +4,11 @@ import { geom2, geom3 } from '../../geometries/index.js'
 
 import { subtract } from './index.js'
 
-test('subtract error wrong number of arguments', (t) => {
-  const message = 'subtract wrong number of arguments'
-  t.throws(() => subtract(), { message })
-  t.throws(() => subtract([]), { message })
-  t.throws(() => subtract([[], []]), { message })
+test('subtract empty arguments', (t) => {
+  t.is(subtract(), undefined)
+  t.is(subtract([]), undefined)
+  t.is(subtract([[], []]), undefined)
+  t.is(subtract(null, null), undefined)
 })
 
 test('subtract error different geometry types', (t) => {
@@ -20,6 +20,5 @@ test('subtract error non-geometries', (t) => {
   const message = 'subtract unsupported geometry type'
   t.throws(() => subtract([1, 2, 3], [4, 5, 6]), { message })
   t.throws(() => subtract([], [123]), { message })
-  t.throws(() => subtract("one", "two"), { message })
-  t.throws(() => subtract(null, null), { message })
+  t.throws(() => subtract('one', 'two'), { message })
 })

package/src/operations/booleans/subtractGeom2.js

@@ -1,17 +1,13 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { DIFFERENCE } from './martinez/operation.js'
 import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing space in the first geometry but
  * not in the subsequent geometries. None of the given geometries are modified.
- * @param {...geom2} geometries - list of geometries
+ * @param {Geom2[]} geometries - a flat list of 2D geometries
  * @returns {Geom2} new 2D geometry
  */
-export const subtractGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const subtractGeom2 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = boolean(newGeometry, geometry, DIFFERENCE)

package/src/operations/booleans/subtractGeom2.test.js

@@ -6,7 +6,7 @@ import { geom2 } from '../../geometries/index.js'
 
 import { measureArea } from '../../measurements/index.js'
 
-import { circle, rectangle } from '../../primitives/index.js'
+import { circle, rectangle, square } from '../../primitives/index.js'
 
 import { center } from '../transforms/index.js'
 
@@ -75,3 +75,27 @@ test('subtract: subtract of one or more geom2 objects produces expected geometry
   t.is(obs.length, 0)
   t.deepEqual(obs, exp)
 })
+
+test('subtract with undefined/null values', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})
+
+test('subtract of nested arrays', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = subtract(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 8)
+})

package/src/operations/booleans/subtractGeom3.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { retessellate } from '../modifiers/retessellate.js'
 
 import { subtractGeom3Sub } from './subtractGeom3Sub.js'
@@ -7,12 +5,10 @@ import { subtractGeom3Sub } from './subtractGeom3Sub.js'
 /*
  * Return a new 3D geometry representing space in this geometry but not in the given geometries.
  * Neither this geometry nor the given geometries are modified.
- * @param {...geom3} geometries - list of geometries
+ * @param {Geom3[]} geometries - a flat list of 3D geometries
  * @returns {Geom3} new 3D geometry
  */
-export const subtractGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const subtractGeom3 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = subtractGeom3Sub(newGeometry, geometry)

package/src/operations/booleans/subtractGeom3.test.js

@@ -4,7 +4,7 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { sphere, cuboid } from '../../primitives/index.js'
 
@@ -69,6 +69,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureArea(result1), 44.053756306589825)
   t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -79,6 +80,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const result2 = subtract(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows.skip(() => geom3.validate(result2))
+  t.is(measureArea(result2), 44.053756306589825)
   t.is(measureVolume(result2), 25.751611331979678)
   t.is(obs.length, 32)
 
@@ -102,6 +104,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
     [[12, 9, 8], [12, 8, 8], [9, 8, 8], [9, 9, 8]]
   ]
   t.notThrows.skip(() => geom3.validate(result3))
+  t.is(measureArea(result3), 96)
   t.is(measureVolume(result3), 63)
   t.is(obs.length, 12)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -110,6 +113,7 @@ test('subtract: subtract of one or more geom3 objects produces expected geometry
   const result4 = subtract(geometry1, geometry3)
   obs = geom3.toPoints(result4)
   t.notThrows(() => geom3.validate(result4))
+  t.is(measureArea(result4), 0)
   t.is(measureVolume(result4), 0)
   t.is(obs.length, 0)
 })

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

@@ -0,0 +1,33 @@
+import { Poly3 } from '../../../geometries/types';
+import { Plane } from '../../../maths/types';
+
+enum ResType
+{
+    coplanar_front = 0,
+    coplanar_back = 1,
+    front = 2,
+    back = 3,
+    spanning = 4,
+}
+
+
+interface SplitRes
+{
+    type: ResType,
+    front: Poly3,
+    back: Poly3;
+}
+
+// Returns object:
+// .type:
+//   0: coplanar-front
+//   1: coplanar-back
+//   2: front
+//   3: back
+//   4: spanning
+// 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;

package/src/operations/booleans/union.js

@@ -1,5 +1,5 @@
 import { areAllShapesTheSameType } from '../../utils/areAllShapesTheSameType.js'
-import { flatten } from '../../utils/flatten.js'
+import { coalesce } from '../../utils/coalesce.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as geom3 from '../../geometries/geom3/index.js'
@@ -12,11 +12,11 @@ import { unionGeom3 } from './unionGeom3.js'
  * The given geometries should be of the same type, either geom2 or geom3.
  *
  * @param {...Object} geometries - list of geometries
- * @returns {Geom2|geom3} a new geometry
+ * @returns {Geom2|Geom3} a new geometry
  * @alias module:modeling/booleans.union
  *
  * @example
- * let myshape = union(cube({size: [5,5,5]}), cube({size: [5,5,5], center: [5,5,5]}))
+ * let myshape = union(cube({size: 5}), cube({size: 5, center: [3,3,3]}))
  *
  * @example
  * +-------+            +-------+
@@ -29,9 +29,9 @@ import { unionGeom3 } from './unionGeom3.js'
  *      +-------+            +-------+
  */
 export const union = (...geometries) => {
-  geometries = flatten(geometries)
-  if (geometries.length === 0) throw new Error('union wrong number of arguments')
+  geometries = coalesce(geometries)
 
+  if (geometries.length === 0) return undefined
   if (!areAllShapesTheSameType(geometries)) {
     throw new Error('union arguments must be the same geometry type')
   }

package/src/operations/booleans/union.test.js

@@ -4,11 +4,11 @@ import { geom2, geom3 } from '../../geometries/index.js'
 
 import { union } from './index.js'
 
-test('union error wrong number of arguments', (t) => {
-  const message = 'union wrong number of arguments'
-  t.throws(() => union(), { message })
-  t.throws(() => union([]), { message })
-  t.throws(() => union([[], []]), { message })
+test('union empty arguments', (t) => {
+  t.is(union(), undefined)
+  t.is(union([]), undefined)
+  t.is(union([[], []]), undefined)
+  t.is(union(null, null), undefined)
 })
 
 test('union error different geometry types', (t) => {
@@ -20,6 +20,5 @@ test('union error non-geometries', (t) => {
   const message = 'union unsupported geometry type'
   t.throws(() => union([1, 2, 3], [4, 5, 6]), { message })
   t.throws(() => union([], [123]), { message })
-  t.throws(() => union("one", "two"), { message })
-  t.throws(() => union(null, null), { message })
+  t.throws(() => union('one', 'two'), { message })
 })

package/src/operations/booleans/unionGeom2.js

@@ -1,16 +1,12 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { UNION } from './martinez/operation.js'
 import { boolean } from './martinez/index.js'
 
 /*
  * Return a new 2D geometry representing the total space in the given 2D geometries.
- * @param {...geom2} geometries - list of 2D geometries to union
+ * @param {Geom2[]} geometries - a flat list of 2D geometries to union
  * @returns {Geom2} new 2D geometry
  */
-export const unionGeom2 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const unionGeom2 = (geometries) => {
   let newGeometry = geometries.shift()
   geometries.forEach((geometry) => {
     newGeometry = boolean(newGeometry, geometry, UNION)

package/src/operations/booleans/unionGeom2.test.js

@@ -6,7 +6,7 @@ import { geom2 } from '../../geometries/index.js'
 
 import { measureArea } from '../../measurements/index.js'
 
-import { circle, rectangle } from '../../primitives/index.js'
+import { circle, rectangle, square } from '../../primitives/index.js'
 
 import { center, translate } from '../transforms/index.js'
 
@@ -209,3 +209,27 @@ test('union of geom2 with colinear edge (martinez issue #155)', (t) => {
   t.is(pts.length, 5)
   t.true(comparePoints(pts, exp))
 })
+
+test('union with undefined/null values', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, undefined, square2, null, square3]
+
+  const obs = union(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})
+
+test('union of nested arrays', (t) => {
+  const square1 = square({ size: 8 })
+  const square2 = square({ size: 6 })
+  const square3 = square({ size: 4 })
+  const geometries = [square1, [square2, [square3]]]
+
+  const obs = union(...geometries)
+  const pts = geom2.toPoints(obs)
+  t.notThrows(() => geom2.validate(obs))
+  t.is(pts.length, 4)
+})

package/src/operations/booleans/unionGeom3.js

@@ -1,17 +1,13 @@
-import { flatten } from '../../utils/flatten.js'
-
 import { retessellate } from '../modifiers/retessellate.js'
 
 import { unionGeom3Sub } from './unionGeom3Sub.js'
 
 /*
  * Return a new 3D geometry representing the space in the given 3D geometries.
- * @param {...objects} geometries - list of geometries to union
+ * @param {Geom3[]} geometries - a flat list of 3D geometries to union
  * @returns {Geom3} new 3D geometry
  */
-export const unionGeom3 = (...geometries) => {
-  geometries = flatten(geometries)
-
+export const unionGeom3 = (geometries) => {
   // combine geometries in a way that forms a balanced binary tree pattern
   let i
   for (i = 1; i < geometries.length; i += 2) {

package/src/operations/booleans/unionGeom3.test.js

@@ -4,7 +4,7 @@ import { comparePolygonsAsPoints } from '../../../test/helpers/index.js'
 
 import { geom3 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { sphere, cuboid } from '../../primitives/index.js'
 
@@ -69,6 +69,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[8.65956056235493e-17, 8.659560562354935e-17, 2], [1.4142135623730951, 3.4638242249419736e-16, 1.414213562373095], [0.9999999999999998, 1.0000000000000002, 1.414213562373095]]
   ]
   t.notThrows.skip(() => geom3.validate(result1))
+  t.is(measureArea(result1), 44.053756306589825)
   t.is(measureVolume(result1), 25.751611331979678)
   t.is(obs.length, 32)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -79,6 +80,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
   const result2 = union(geometry1, geometry2)
   obs = geom3.toPoints(result2)
   t.notThrows.skip(() => geom3.validate(result2))
+  t.is(measureArea(result2), 140.05375630658983)
   t.is(measureVolume(result2), 89.75161133197969)
   t.is(obs.length, 38)
 
@@ -108,6 +110,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, 8, 9], [-9, -9, 9], [9, -9, 9], [9, 8, 9]]
   ]
   t.notThrows.skip(() => geom3.validate(result3))
+  t.is(measureArea(result3), 2034)
   t.is(measureVolume(result3), 5895)
   t.is(obs.length, 18)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -124,6 +127,7 @@ test('union of one or more geom3 objects produces expected geometry', (t) => {
     [[-9, -9, 9], [9, -9, 9], [9, 9, 9], [-9, 9, 9]]
   ]
   t.notThrows(() => geom3.validate(result4))
+  t.is(measureArea(result4), 1944)
   t.is(measureVolume(result4), 5832)
   t.is(obs.length, 6)
   t.true(comparePolygonsAsPoints(obs, exp))
@@ -136,6 +140,7 @@ test('union of geom3 with rounding issues #137', (t) => {
   const result = union(geometry1, geometry2)
   const pts = geom3.toPoints(result)
   t.notThrows(() => geom3.validate(result))
+  t.is(measureArea(result), 3240.00014)
   t.is(measureVolume(result), 7779.201144000001)
   t.is(pts.length, 6) // number of polygons in union
 })

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

@@ -7,7 +7,7 @@ import { mat4 } from '../../maths/index.js'
 
 import { geom2, geom3, poly3, slice } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { circle, square } from '../../primitives/index.js'
 
@@ -32,6 +32,8 @@ test('extrudeFromSlices (defaults)', (t) => {
     [[-10, -10, 0], [-10, 10, 0], [10, 10, 0]],
     [[10, 10, 0], [10, -10, 0], [-10, -10, 0]]
   ]
+  t.is(measureArea(geometry3), 880)
+  t.is(measureVolume(geometry3), 400.00000000000006)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
 
@@ -40,6 +42,7 @@ test('extrudeFromSlices (defaults)', (t) => {
   pts = geom3.toPoints(geometry3)
 
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 880)
   t.is(measureVolume(geometry3), 400.00000000000006)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -74,6 +77,7 @@ test('extrudeFromSlices (torus)', (t) => {
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 7070.694617452831)
   t.is(measureVolume(geometry3), 29393.876913398108)
   t.is(pts.length, 96)
 })
@@ -95,6 +99,7 @@ test('extrudeFromSlices (same shape, changing dimensions)', (t) => {
   const pts = geom3.toPoints(geometry3)
   // expected to throw because capEnd is false (non-closed geometry)
   t.throws(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 53.70100297794013)
   t.is(measureVolume(geometry3), 8.5)
   t.is(pts.length, 26)
 })
@@ -114,6 +119,7 @@ test('extrudeFromSlices (changing shape, changing dimensions)', (t) => {
   )
   const pts = geom3.toPoints(geometry3)
   t.notThrows.skip(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1965.8643589631802)
   t.is(measureVolume(geometry3), 5260.067107417433)
   t.is(pts.length, 304)
 })
@@ -160,6 +166,7 @@ test('extrudeFromSlices (holes)', (t) => {
     [[-5, -5, 0], [5, -5, 0], [-10, -10, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 720)
   t.is(measureVolume(geometry3), 300)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/extrudeHelical.js

@@ -19,14 +19,8 @@ import { extrudeFromSlices } from './extrudeFromSlices.js'
  * @alias module:modeling/extrusions.extrudeHelical
  *
  * @example
- * const myshape = extrudeHelical(
- *  {
- *      angle: Math.PI * 4,
- *      pitch: 10,
- *      segmentsPerRotation: 64
- *  },
- *  circle({size: 3, center: [10, 0]})
- * )
+ * const myshape = circle({size: 3, center: [10, 0]}) // position for extrusion about Z
+ * const mycoil = extrudeHelical({angle: TAU*2, pitch: 10, segmentsPerRotation: 64}, myshape))
  */
 export const extrudeHelical = (options, geometry) => {
   const defaults = {

package/src/operations/extrusions/extrudeLinear.js

@@ -1,5 +1,3 @@
-import { flatten } from '../../utils/flatten.js'
-
 import * as geom2 from '../../geometries/geom2/index.js'
 import * as path2 from '../../geometries/path2/index.js'
 
@@ -30,15 +28,13 @@ export const extrudeLinear = (options, ...objects) => {
   }
   const { height, twistAngle, twistSteps, repair } = Object.assign({ }, defaults, options)
 
-  objects = flatten(objects)
-  if (objects.length === 0) throw new Error('wrong number of arguments')
-
   options = { offset: [0, 0, height], twistAngle, twistSteps, repair }
 
   const results = objects.map((object) => {
     if (path2.isA(object)) return extrudeLinearPath2(options, object)
     if (geom2.isA(object)) return extrudeLinearGeom2(options, object)
     // if (geom3.isA(object)) return geom3.extrude(options, object)
+    if (Array.isArray(object)) return extrudeLinear(options, ...object)
     return object
   })
   return results.length === 1 ? results[0] : results

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

@@ -8,7 +8,7 @@ import { colorize } from '../../colors/index.js'
 
 import { geom2, geom3, path2 } from '../../geometries/index.js'
 
-import { measureVolume } from '../../measurements/index.js'
+import { measureArea, measureVolume } from '../../measurements/index.js'
 
 import { square } from '../../primitives/index.js'
 
@@ -34,6 +34,7 @@ test('extrudeLinear (defaults)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 240)
   t.is(measureVolume(geometry3), 100.00000000000001)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -70,6 +71,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 800)
   t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -91,6 +93,7 @@ test('extrudeLinear (no twist)', (t) => {
     [[5, -5, 0], [5, 5, 0], [-5, 5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 800)
   t.is(measureVolume(geometry3), 1500)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -124,6 +127,7 @@ test('extrudeLinear (twist)', (t) => {
     [[5, 5, 0], [5, -5, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 805.6920958788816)
   t.is(measureVolume(geometry3), 1707.1067811865476)
   t.is(pts.length, 12)
   t.true(comparePolygonsAsPoints(pts, exp))
@@ -166,6 +170,7 @@ test('extrudeLinear (twist)', (t) => {
   geometry3 = extrudeLinear({ height: 15, twistAngle: TAU / 2, twistSteps: 30 }, geometry2)
   pts = geom3.toPoints(geometry3)
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1091.9932843446968)
   t.is(measureVolume(geometry3), 1444.9967160503095)
   t.is(pts.length, 244)
 })
@@ -212,6 +217,7 @@ test('extrudeLinear (holes)', (t) => {
     [[-2, -2, 0], [2, -2, 0], [-5, -5, 0]]
   ]
   t.notThrows(() => geom3.validate(geometry3))
+  t.is(measureArea(geometry3), 1008)
   t.is(measureVolume(geometry3), 1260)
   t.is(pts.length, 32)
   t.true(comparePolygonsAsPoints(pts, exp))

package/src/operations/extrusions/extrudeRotate.js

@@ -4,6 +4,7 @@ import * as mat4 from '../../maths/mat4/index.js'
 import { mirrorX } from '../transforms/mirror.js'
 
 import * as geom2 from '../../geometries/geom2/index.js'
+import * as geom3 from '../../geometries/geom3/index.js'
 import * as slice from '../../geometries/slice/index.js'
 
 import { extrudeFromSlices } from './extrudeFromSlices.js'
@@ -58,7 +59,7 @@ export const extrudeRotate = (options, geometry) => {
 
   // convert geometry to an array of sides, easier to deal with
   let shapeSides = geom2.toSides(geometry)
-  if (shapeSides.length === 0) return geometry
+  if (shapeSides.length === 0) return geom3.create()
   let sliceGeometry = geometry
 
   // determine if the extrusion can be computed in the first place
@@ -88,7 +89,7 @@ export const extrudeRotate = (options, geometry) => {
         return [point0, point1]
       })
       // recreate the geometry from the (-) capped points
-      sliceGeometry = geom2.reverse(geom2.fromSides(shapeSides))
+      sliceGeometry = geom2.fromSides(shapeSides)
       sliceGeometry = mirrorX(sliceGeometry)
     } else if (pointsWithPositiveX.length >= pointsWithNegativeX.length) {
       shapeSides = shapeSides.map((side) => {